cryptum 0.0.355 → 0.0.356

data/lib/cryptum/api.rb

@@ -1,688 +0,0 @@
-# frozen_string_literal: true
-
-require 'addressable'
-require 'base64'
-require 'json'
-require 'openssl'
-require 'rest-client'
-
-module Cryptum
-  # This plugin is used to interact withbtje Coinbase REST API
-  module API
-    # Supported Method Parameters::
-    # Cryptum::API.generate_signature(
-    # )
-
-    public_class_method def self.generate_signature(opts = {})
-      api_secret = opts[:api_secret]
-
-      http_method = if opts[:http_method].nil?
-                      :GET
-                    else
-                      opts[:http_method].to_s.upcase.scrub.strip.chomp.to_sym
-                    end
-
-      api_call = opts[:api_call].to_s.scrub.strip.chomp
-      api_call = '/users/self/verify' if opts[:api_call].nil?
-
-      if opts[:params].nil?
-        path = api_call
-      else
-        uri = Addressable::URI.new
-        uri.query_values = opts[:params]
-        params = uri.query
-        path = "#{api_call}?#{params}"
-      end
-
-      http_body = opts[:http_body].to_s.scrub.strip.chomp
-
-      api_timestamp = Time.now.utc.to_i.to_s
-
-      api_signature = Base64.strict_encode64(
-        OpenSSL::HMAC.digest(
-          'sha256',
-          Base64.strict_decode64(api_secret),
-          "#{api_timestamp}#{http_method}#{path}#{http_body}"
-        )
-      )
-
-      if http_body == ''
-        api_signature = Base64.strict_encode64(
-          OpenSSL::HMAC.digest(
-            'sha256',
-            Base64.strict_decode64(api_secret),
-            "#{api_timestamp}#{http_method}#{path}"
-          )
-        )
-      end
-
-      api_signature_response = {}
-      api_signature_response[:api_timestamp] = api_timestamp
-      api_signature_response[:api_signature] = api_signature
-
-      api_signature_response
-    rescue RestClient::ExceptionWithResponse => 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 "URL: #{api_endpoint}#{api_call}"
-        f.puts "PARAMS: #{params.inspect}"
-        f.puts "HTTP POST BODY: #{http_body.inspect}" if http_body != ''
-        f.puts "#{e}\n#{e.response}\n\n\n"
-      end
-    rescue StandardError => e
-      raise e
-    end
-
-    private_class_method def self.rest_api_call(opts = {})
-      env = opts[:env]
-      option_choice = opts[:option_choice]
-      order_type = opts[:order_type]
-      event_notes = opts[:event_notes]
-      api_endpoint = opts[:api_endpoint]
-      base_increment = opts[:base_increment].to_f
-
-      api_key = env[:api_key]
-      api_secret = env[:api_secret]
-      api_passphrase = env[:api_passphrase]
-      api_endpoint = 'https://api.exchange.coinbase.com'
-      api_endpoint = 'https://api-public.sandbox.exchange.coinbase.com' if env[:env] == :sandbox
-      api_endpoint = opts[:api_endpoint] if opts[:api_endpoint]
-
-      http_method = if opts[:http_method].nil?
-                      :GET
-                    else
-                      opts[:http_method].to_s.upcase.scrub.strip.chomp.to_sym
-                    end
-      api_call = opts[:api_call].to_s.scrub
-      params = opts[:params]
-      http_body = opts[:http_body].to_s.scrub.strip.chomp
-
-      max_conn_attempts = 30
-      conn_attempt = 0
-
-      begin
-        conn_attempt += 1
-        if option_choice.proxy
-          rest_client = RestClient
-          rest_client.proxy = option_choice.proxy
-          rest_client_request = rest_client::Request
-        else
-          rest_client_request = RestClient::Request
-        end
-
-        api_signature_response = generate_signature(
-          api_secret: api_secret,
-          http_method: http_method,
-          api_call: api_call,
-          params: params,
-          http_body: http_body
-        )
-        api_signature = api_signature_response[:api_signature]
-        api_timestamp = api_signature_response[:api_timestamp]
-
-        case http_method
-        when :GET
-          headers = {
-            content_type: 'application/json; charset=UTF-8',
-            CB_ACCESS_TIMESTAMP: api_timestamp,
-            CB_ACCESS_PASSPHRASE: api_passphrase,
-            CB_ACCESS_KEY: api_key,
-            CB_ACCESS_SIGN: api_signature
-          }
-
-          headers[:params] = params if params
-          headers[:ORDER_TYPE] = order_type if order_type
-          headers[:EVENT_NOTES] = event_notes if event_notes
-
-          response = rest_client_request.execute(
-            method: :GET,
-            url: "#{api_endpoint}#{api_call}",
-            headers: headers,
-            verify_ssl: false
-          )
-
-        when :DELETE
-          headers = {
-            content_type: 'application/json; charset=UTF-8',
-            CB_ACCESS_TIMESTAMP: api_timestamp,
-            CB_ACCESS_PASSPHRASE: api_passphrase,
-            CB_ACCESS_KEY: api_key,
-            CB_ACCESS_SIGN: api_signature
-          }
-
-          headers[:params] = params if params
-          headers[:ORDER_TYPE] = order_type if order_type
-          headers[:EVENT_NOTES] = event_notes if event_notes
-
-          response = rest_client_request.execute(
-            method: :DELETE,
-            url: "#{api_endpoint}#{api_call}",
-            headers: headers,
-            verify_ssl: false
-          )
-
-        when :POST
-          headers = {
-            content_type: 'application/json; charset=UTF-8',
-            CB_ACCESS_TIMESTAMP: api_timestamp,
-            CB_ACCESS_PASSPHRASE: api_passphrase,
-            CB_ACCESS_KEY: api_key,
-            CB_ACCESS_SIGN: api_signature
-          }
-
-          headers[:params] = params if params
-          headers[:ORDER_TYPE] = order_type if order_type
-          headers[:EVENT_NOTES] = event_notes if event_notes
-
-          response = rest_client_request.execute(
-            method: :POST,
-            url: "#{api_endpoint}#{api_call}",
-            headers: headers,
-            payload: http_body,
-            verify_ssl: false
-          )
-
-        else
-          raise @@logger.error("Unsupported HTTP Method #{http_method} for #{self} Plugin")
-        end
-
-        JSON.parse(response, symbolize_names: true)
-      rescue RestClient::Unauthorized => 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 "#{self}\n#{e}\n\n\n"
-        end
-
-        raise e if conn_attempt > max_conn_attempts
-
-        sleep 60
-        retry
-      end
-    rescue RestClient::ExceptionWithResponse => 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 "URL: #{api_endpoint}#{api_call}"
-        f.puts "PARAMS: #{params.inspect}"
-        f.puts "HTTP POST BODY: #{http_body.inspect}" if http_body != ''
-        f.puts "#{e}\n#{e.response}\n\n\n"
-      end
-
-      insufficient_funds = '{"message":"Insufficient funds"}'
-      size -= base_increment if e.response == insufficient_funds
-
-      sleep 0.3
-      retry
-    rescue RestClient::TooManyRequests => 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 "URL: #{api_endpoint}#{api_call}"
-        f.puts "PARAMS: #{params.inspect}"
-        f.puts "HTTP POST BODY: #{http_body.inspect}" if http_body != ''
-        f.puts "#{e}\n#{e.response}\n\n\n"
-      end
-
-      sleep 1
-      retry
-    end
-
-    public_class_method def self.submit_limit_order(opts = {})
-      option_choice = opts[:option_choice]
-      env = opts[:env]
-      price = opts[:price]
-      size = opts[:size]
-      buy_or_sell = opts[:buy_or_sell]
-      event_history = opts[:event_history]
-      bot_conf = opts[:bot_conf]
-      buy_order_id = opts[:buy_order_id]
-
-      tpm = bot_conf[:target_profit_margin_percent].to_f
-      tpm_cast_as_decimal = tpm / 100
-
-      product_id = option_choice.symbol.to_s.gsub('_', '-').upcase
-
-      this_product = event_history.order_book[:this_product]
-      base_increment = this_product[:base_increment]
-      quote_increment = this_product[:quote_increment]
-      # crypto_smallest_decimal = base_increment.to_s.split('.')[-1].length
-      fiat_smallest_decimal = quote_increment.to_s.split('.')[-1].length
-
-      order_hash = {}
-
-      order_hash[:type] = 'limit'
-      order_hash[:time_in_force] = 'GTC'
-
-      if buy_or_sell == :buy
-        order_hash[:time_in_force] = 'GTT'
-        order_hash[:cancel_after] = 'min'
-      end
-
-      order_hash[:size] = size
-      order_hash[:price] = price
-      order_hash[:side] = buy_or_sell
-      order_hash[:product_id] = product_id
-
-      http_body = order_hash.to_json
-
-      limit_order_resp = rest_api_call(
-        option_choice: option_choice,
-        env: env,
-        http_method: :POST,
-        api_call: '/orders',
-        http_body: http_body,
-        base_increment: base_increment
-      )
-
-      # Populate Order ID on the Buy
-      # to know what to do on the Sell
-      case buy_or_sell
-      when :buy
-        this_order = event_history.order_book[:order_plan].shift
-        this_order[:buy_order_id] = limit_order_resp[:id]
-        this_order[:price] = price
-        targ_price = price.to_f + (price.to_f * tpm_cast_as_decimal)
-        this_order[:tpm] = format(
-          '%0.2f',
-          tpm
-        )
-        this_order[:target_price] = format(
-          "%0.#{fiat_smallest_decimal}f",
-          targ_price
-        )
-
-        this_order[:size] = size
-
-        this_order[:color] = :cyan
-        event_history.order_book[:order_history_meta].push(this_order)
-      when :sell
-        sell_order_id = limit_order_resp[:id]
-        event_history.order_book[:order_history_meta].each do |meta|
-          if meta[:buy_order_id] == buy_order_id
-            meta[:sell_order_id] = sell_order_id
-            meta[:color] = :yellow
-          end
-        end
-      end
-
-      event_history
-    rescue StandardError => e
-      raise e
-    end
-
-    public_class_method def self.gtfo(opts = {})
-      option_choice = opts[:option_choice]
-      env = opts[:env]
-      event_history = opts[:event_history]
-
-      # Cancel all open orders
-      cancel_all_open_orders(
-        env: env,
-        option_choice: option_choice
-      )
-
-      product_id = option_choice.symbol.to_s.gsub('_', '-').upcase
-
-      this_product = event_history.order_book[:this_product]
-      base_increment = this_product[:base_increment]
-      quote_increment = this_product[:quote_increment]
-      crypto_smallest_decimal = base_increment.to_s.split('.')[-1].length
-      fiat_smallest_decimal = quote_increment.to_s.split('.')[-1].length
-
-      # TODO: Calculate / Price / Size
-      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.sort[1]
-      price = format(
-        "%0.#{fiat_smallest_decimal}f",
-        limit_price
-      )
-
-      crypto_currency = option_choice.symbol.to_s.upcase.split('_').first.to_sym
-      portfolio = event_history.order_book[:portfolio]
-      this_account = portfolio.select do |account|
-        account[:currency] == crypto_currency.to_s
-      end
-      balance = format(
-        "%0.#{crypto_smallest_decimal}f",
-        this_account.first[:balance]
-      )
-
-      current_crypto_fiat_value = format(
-        '%0.2f',
-        balance.to_f * price.to_f
-      )
-
-      order_hash = {}
-
-      order_hash[:type] = 'limit'
-      order_hash[:time_in_force] = 'GTT'
-      order_hash[:cancel_after] = 'min'
-
-      order_hash[:size] = balance
-      order_hash[:price] = price
-      order_hash[:side] = :sell
-      order_hash[:product_id] = product_id
-
-      http_body = order_hash.to_json
-
-      limit_order_resp = rest_api_call(
-        option_choice: option_choice,
-        env: env,
-        http_method: :POST,
-        api_call: '/orders',
-        http_body: http_body,
-        base_increment: base_increment
-      )
-
-      # Populate Order ID on the Buy
-      # to know what to do on the Sell
-      this_order = {}
-      this_order[:plan_no] = '0.0'
-      this_order[:fiat_available] = '0.00'
-      this_order[:risk_alloc] = current_crypto_fiat_value
-      this_order[:allocation_decimal] = '1.0'
-      this_order[:allocation_percent] = '100.0'
-      this_order[:invest] = current_crypto_fiat_value
-      this_order[:return] = current_crypto_fiat_value
-      this_order[:profit] = '0.0'
-      this_order[:buy_order_id] = 'N/A'
-      this_order[:price] = price
-      this_order[:tpm] = '0.00'
-      this_order[:target_price] = current_crypto_fiat_value
-      this_order[:size] = balance
-      this_order[:color] = :magenta
-      this_order[:sell_order_id] = limit_order_resp[:id]
-
-      event_history.order_book[:order_history_meta].push(this_order)
-
-      event_history
-    rescue StandardError => e
-      raise e
-    end
-
-    # public_class_method def self.cancel_open_order(opts = {})
-    #   env = opts[:env]
-    #   option_choice = opts[:option_choice]
-    #   order_id = opts[:order_id]
-    #   order_type = opts[:order_type]
-
-    #   product_id = option_choice.symbol.to_s.gsub('_', '-').upcase
-
-    #   order_hash = {}
-    #   order_hash[:product_id] = product_id
-
-    #   params = order_hash
-
-    #   rest_api_call(
-    #     env: env,
-    #     http_method: :DELETE,
-    #     api_call: "/orders/#{order_id}",
-    #     option_choice: option_choice,
-    #     params: params,
-    #     order_type: order_type
-    #   )
-    # rescue StandardError => e
-    #   raise e
-    # end
-
-    public_class_method def self.cancel_all_open_orders(opts = {})
-      env = opts[:env]
-      option_choice = opts[:option_choice]
-      event_notes = opts[:event_notes]
-
-      product_id = option_choice.symbol.to_s.gsub('_', '-').upcase
-
-      order_hash = {}
-      order_hash[:product_id] = product_id
-
-      # http_body = order_hash.to_json
-      params = order_hash
-
-      canceled_order_id_arr = []
-      loop do
-        canceled_order_id_arr = rest_api_call(
-          env: env,
-          http_method: :DELETE,
-          api_call: '/orders',
-          option_choice: option_choice,
-          params: params,
-          event_notes: event_notes
-        )
-
-        break if canceled_order_id_arr.empty?
-      end
-      canceled_order_id_arr
-    rescue StandardError => e
-      raise e
-    end
-
-    public_class_method def self.get_products(opts = {})
-      option_choice = opts[:option_choice]
-      env = opts[:env]
-
-      products = rest_api_call(
-        option_choice: option_choice,
-        env: env,
-        http_method: :GET,
-        api_call: '/products'
-      )
-
-      if products.length.positive?
-        supported_products_filter = products.select do |product|
-          product[:id].match?(/USD$/) &&
-            product[:status] == 'online' &&
-            product[:fx_stablecoin] == false
-        end
-        sorted_products = supported_products_filter.sort_by { |hash| hash[:id] }
-      end
-
-      sorted_products
-    rescue StandardError => e
-      raise e
-    end
-
-    private_class_method def self.get_exchange_rates(opts = {})
-      option_choice = opts[:option_choice]
-      env = opts[:env]
-
-      api_endpoint = 'https://api.coinbase.com/v2'
-      exchange_rates_api_call = '/exchange-rates'
-
-      # We don't always get fees back from Coinbase...
-      # This is a hack to ensure we do.
-      exchange = {}
-      exchange = rest_api_call(
-        option_choice: option_choice,
-        env: env,
-        http_method: :GET,
-        api_endpoint: api_endpoint,
-        api_call: exchange_rates_api_call
-      )
-
-      exchange[:data][:rates]
-    rescue StandardError => e
-      raise e
-    end
-
-    public_class_method def self.get_portfolio(opts = {})
-      option_choice = opts[:option_choice]
-      env = opts[:env]
-      crypto = opts[:crypto]
-      fiat = opts[:fiat]
-      fiat_portfolio_file = opts[:fiat_portfolio_file]
-      event_notes = opts[:event_notes]
-
-      # Retrieve Exchange Rates
-      exchange_rates = get_exchange_rates(
-        option_choice: option_choice,
-        env: env
-      )
-
-      portfolio_complete_arr = []
-      portfolio_complete_arr = rest_api_call(
-        option_choice: option_choice,
-        env: env,
-        http_method: :GET,
-        api_call: '/accounts',
-        event_notes: event_notes
-      )
-
-      all_products = portfolio_complete_arr.select do |products|
-        products if products[:balance].to_f.positive?
-      end
-
-      total_holdings = 0.00
-      all_products.each do |product|
-        currency = product[:currency].to_sym
-        this_exchange_rate = exchange_rates[currency].to_f
-        total_holdings += product[:balance].to_f / this_exchange_rate
-      end
-
-      crypto_portfolio = portfolio_complete_arr.select do |product|
-        product if product[:currency] == crypto
-      end
-
-      fiat_portfolio = portfolio_complete_arr.select do |product|
-        product if product[:currency] == fiat
-      end
-      fiat_portfolio.last[:total_holdings] = format(
-        '%0.8f',
-        total_holdings
-      )
-
-      File.write(
-        fiat_portfolio_file,
-        JSON.pretty_generate(fiat_portfolio)
-      )
-
-      crypto_portfolio
-    rescue StandardError => e
-      raise e
-    end
-
-    public_class_method def self.get_fees(opts = {})
-      option_choice = opts[:option_choice]
-      env = opts[:env]
-
-      fees_api_call = '/fees'
-
-      # We don't always get fees back from Coinbase...
-      # This is a hack to ensure we do.
-      fees = {}
-      fees = rest_api_call(
-        option_choice: option_choice,
-        env: env,
-        http_method: :GET,
-        api_call: fees_api_call
-      )
-
-      fees
-    rescue StandardError => e
-      raise e
-    end
-
-    # public_class_method def self.get_profiles(opts = {})
-    #   option_choice = opts[:option_choice]
-    #   env = opts[:env]
-
-    #   profiles_api_call = '/profiles'
-
-    #   # We don't always get fees back from Coinbase...
-    #   # This is a hack to ensure we do.
-    #   profiles = {}
-    #   # loop do
-    #   profiles = rest_api_call(
-    #     option_choice: option_choice,
-    #     env: env,
-    #     http_method: :GET,
-    #     api_call: profiles_api_call
-    #   )
-
-    #   #   break unless fees.empty?
-
-    #   #   sleep 0.3
-    #   # end
-
-    #   profiles
-    # rescue StandardError => e
-    #   raise e
-    # end
-
-    public_class_method def self.get_order_history(opts = {})
-      option_choice = opts[:option_choice]
-      env = opts[:env]
-
-      product_id = option_choice.symbol.to_s.gsub('_', '-').upcase
-
-      orders_api_call = '/orders'
-      params = {}
-      params[:product_id] = product_id
-      params[:status] = 'all'
-
-      # We don't always get order_history back from Coinbase...
-      # This is a hack to ensure we do.
-      order_history = []
-      order_history = rest_api_call(
-        option_choice: option_choice,
-        env: env,
-        http_method: :GET,
-        api_call: orders_api_call,
-        params: params
-      )
-
-      # Cast UTC Timestamps as local times
-      order_history.each do |order|
-        order[:created_at] = Time.parse(
-          order[:created_at]
-        ).localtime.to_s
-
-        next unless order[:done_at]
-
-        order[:done_at] = Time.parse(
-          order[:done_at]
-        ).localtime.to_s
-      end
-
-      order_history
-    rescue StandardError => e
-      raise e
-    end
-
-    # Display Usage for this Module
-
-    public_class_method def self.help
-      puts "USAGE:
-       signature = #{self}.generate_signature(
-         api_secret: 'required - Coinbase Pro API Secret',
-         http_method: 'optional - Defaults to :GET',
-         api_call: 'optional - Defaults to /users/self/verify',
-         params: 'optional - HTTP GET Parameters',
-         http_body: 'optional HTTP POST Body'
-       )
-
-       profiles = #{self}.get_profiles(
-         env: 'required - Coinbase::Option.get_env Object'
-       )
-
-       products = #{self}.get_products(
-         env: 'required - Coinbase::Option.get_env Object'
-       )
-
-       portfolio = #{self}.get_portfolio(
-         env: 'required - Coinbase::Option.get_env Object'
-       )
-
-       order_history = #{self}.get_order_history(
-         env: 'required - Coinbase::Option.get_env Object'
-       )
-      "
-    end
-  end
-end