innox 2.7.6

data/lib/innox/ranger/web_socket.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Innox::Ranger
+  def self.run(jwt_public_key, exchange_name, opts={})
+    host = opts[:ranger_host] || ENV["RANGER_HOST"] || "0.0.0.0"
+    port = opts[:ranger_port] || ENV["RANGER_PORT"] || "8081"
+
+    authenticator = Innox::Auth::JWTAuthenticator.new(jwt_public_key)
+
+    logger = Innox::Logger.logger
+    logger.info "Starting the server on port #{port}"
+
+    client = Innox::MQ::Client.new
+    router = Innox::Ranger::Router.new(opts[:registry])
+    client.subscribe(exchange_name, &router.method(:on_message))
+
+    if opts[:display_stats]
+      EM.add_periodic_timer(opts[:stats_period]) do
+        Innox::Logger.logger.info { router.stats }
+        Innox::Logger.logger.debug { router.debug }
+      end
+    end
+
+    EM::WebSocket.start(host: host, port: port, secure: false) do |socket|
+      connection = Innox::Ranger::Connection.new(router, socket, logger)
+      socket.onopen do |hs|
+        connection.handshake(authenticator, hs)
+        router.on_connection_open(connection)
+      end
+
+      socket.onmessage do |msg|
+        connection.handle(msg)
+      end
+
+      socket.onping do |value|
+        logger.debug { "Received ping: #{value}" }
+      end
+
+      socket.onclose do
+        logger.debug { "Websocket connection closed" }
+        router.on_connection_close(connection)
+      end
+
+      socket.onerror do |e|
+        logger.error { "WebSocket Error: #{e.message}\n" + e.backtrace.join("\n") }
+      end
+    end
+  end
+
+  def self.run!(jwt_public_key, exchange_name, opts={})
+    metrics_host = opts[:metrics_host] || ENV["METRICS_HOST"] || "0.0.0.0"
+    metrics_port = opts[:metrics_port] || ENV["METRICS_PORT"] || "8082"
+
+    EM.run do
+      run(jwt_public_key, exchange_name, opts)
+
+      if opts[:registry]
+        thin = Rack::Handler.get("thin")
+        thin.run(Innox::Metrics::Server.app(opts[:registry]), Host: metrics_host, Port: metrics_port)
+      end
+
+      trap("INT") do
+        puts "\nSIGINT received, stopping ranger..."
+        EM.stop
+      end
+    end
+  end
+end

data/lib/innox/security/key_generator.rb

@@ -0,0 +1,26 @@
+require 'fileutils'
+
+module Innox::Security
+  class KeyGenerator
+
+    attr_reader :public, :private
+
+    def initialize
+      OpenSSL::PKey::RSA.generate(2048).tap do |pkey|
+        @public = pkey.public_key.to_pem
+        @private = pkey.to_pem
+      end
+    end
+
+    def save(folder)
+      FileUtils.mkdir_p(folder) unless File.exists?(folder)
+
+      write(File.join(folder, 'rsa-key'), @private)
+      write(File.join(folder, 'rsa-key.pub'), @public)
+    end
+
+    def write(filename, text)
+      File.open(filename, 'w') { |file| file.write(text) }
+    end
+  end
+end

data/lib/innox/sql/client.rb

@@ -0,0 +1,19 @@
+module Innox::Sql
+  class Client
+    attr_accessor :client, :config
+
+    def initialize
+      @config = {
+        host: ENV["DATABASE_HOST"] || "localhost",
+        username: ENV["DATABASE_USER"] || "root",
+        password: ENV["DATABASE_PASS"] || "",
+        port: ENV["DATABASE_PORT"] || "3306",
+        database: ENV["DATABASE_NAME"] || "innox_development",
+      }
+    end
+
+    def connect
+      @client = Mysql2::Client.new(config)
+    end
+  end
+end

data/lib/innox/sql/schema.rb

@@ -0,0 +1,72 @@
+module Innox::Sql
+  class Schema
+    attr_accessor :client
+
+    def initialize(sql_client)
+      @client = sql_client
+    end
+
+    def create_database(name)
+      client.query("CREATE DATABASE IF NOT EXISTS `#{ name }`;")
+    end
+
+    def create_tables(options = {})
+      statements = []
+      statements << "DROP TABLE IF EXISTS `operations`;" if options[:drop_if_exists]
+      statements << <<-EOF
+CREATE TABLE IF NOT EXISTS `operations` (
+    id              INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    code            TINYINT UNSIGNED NOT NULL,
+    account_id      INT UNSIGNED NOT NULL,
+    reference       INT UNSIGNED NOT NULL,
+    debit           DECIMAL(32, 16) NOT NULL,
+    credit          DECIMAL(32, 16) NOT NULL,
+    created_at      DATETIME NOT NULL,
+    updated_at      DATETIME NOT NULL,
+    PRIMARY KEY     (id),
+    INDEX `balance_key` (account_id, debit, credit)
+) ENGINE = InnoDB;
+EOF
+
+      statements << "DROP TABLE IF EXISTS `orders`;" if options[:drop_if_exists]
+      statements << <<EOF
+CREATE TABLE IF NOT EXISTS`orders` (
+  `id`          INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
+  `uid`         INT(11) UNSIGNED NOT NULL,
+  `bid`         VARCHAR(5) NOT NULL,
+  `ask`         VARCHAR(5) NOT NULL,
+  `market`      VARCHAR(10) NOT NULL,
+  `price`       DECIMAL(32,16) DEFAULT NULL,
+  `volume`      DECIMAL(32,16) NOT NULL,
+  `fee`         DECIMAL(32,16) NOT NULL DEFAULT '0.0000000000000000',
+  `type`        TINYINT UNSIGNED NOT NULL,
+  `state`       TINYINT UNSIGNED NOT NULL,
+  `created_at`  DATETIME NOT NULL,
+  `updated_at`  DATETIME NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+EOF
+
+      statements << "DROP TABLE IF EXISTS `trades`;" if options[:drop_if_exists]
+      statements << <<EOF
+CREATE TABLE IF NOT EXISTS `trades` (
+  `id`          int(11) NOT NULL AUTO_INCREMENT,
+  `market`      varchar(10) NOT NULL,
+  `volume`      decimal(32,16) NOT NULL,
+  `price`       decimal(32,16) NOT NULL,
+  `ask_id`      int(11) NOT NULL,
+  `bid_id`      int(11) NOT NULL,
+  `ask_uid`     int(11) NOT NULL,
+  `bid_uid`     int(11) NOT NULL,
+  `created_at` datetime NOT NULL,
+  `updated_at` datetime NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+EOF
+      statements.each do |statement|
+        puts statement
+        client.query(statement)
+      end
+    end
+  end
+end

data/lib/innox/transaction.rb

@@ -0,0 +1,136 @@
+require 'active_support/concern'
+require 'active_support/core_ext/string/inquiry'
+require 'active_support/core_ext/object/blank'
+require 'active_model'
+
+module Innox #:nodoc:
+
+  # This class represents blockchain transaction.
+  #
+  # Using the instant of this class the innox application will send/recieve
+  # income/outcome transactions from a innox pluggable blockchain.
+  #
+  # @example
+  #
+  #   Innox::Transaction.new(
+  #     {
+  #       hash: '0x5d0ef9697a2f3ea561c9fbefb48e380a4cf3d26ad2be253177c472fdd0e8b486',
+  #       txout: 1,
+  #       to_address: '0x9af4f143cd5ecfba0fcdd863c5ef52d5ccb4f3e5',
+  #       amount: 0.01,
+  #       fee: 0.0004,
+  #       block_number: 7732274,
+  #       currency_id: 'eth',
+  #       fee_currency_id: 'eth',
+  #       status: 'success'
+  #     }
+  #   )
+  #
+  
+  class Transaction
+    include ActiveModel::Model
+
+    # List of statuses supported by innox.
+    #
+    # @note Statuses list:
+    #
+    #   pending - the transaction is unconfirmed in the blockchain or
+    #   wasn't created yet.
+    #
+    #   success - the transaction is a successfull,
+    #   the transaction amount has been successfully transferred
+    #
+    #   failed - the transaction is failed in the blockchain.
+    #
+    #   rejected - the transaction is rejected by user.
+
+    STATUSES = %w[success pending failed rejected].freeze
+
+    DEFAULT_STATUS = 'pending'.freeze
+
+    # @!attribute [rw] hash
+    # return [String] transaction hash
+    attr_accessor :hash
+
+    # @!attribute [rw] txout
+    # return [Integer] transaction number in send-to-many request
+    attr_accessor :txout
+
+    # @!attribute [rw] from_address
+    # return [Array<String>] transaction source addresses
+    attr_accessor :from_addresses
+
+    # @!attribute [rw] to_address
+    # return [String] transaction recepient address
+    attr_accessor :to_address
+
+    # @!attribute [rw] amount
+    # return [Decimal] amount of the transaction
+    attr_accessor :amount
+
+    # @!attribute [rw] fee
+    # return [Decimal] fee of the transaction
+    attr_accessor :fee
+
+    # @!attribute [rw] block_number
+    # return [Integer] transaction block number
+    attr_accessor :block_number
+
+    # @!attribute [rw] currency_id
+    # return [String] transaction currency id
+    attr_accessor :currency_id
+
+    # @!attribute [rw] fee_currency_id
+    # return [String] transaction fee currency id
+    attr_accessor :fee_currency_id
+
+    # @!attribute [rw] options
+    # return [JSON] transaction options
+    attr_accessor :options
+
+    validates :to_address,
+              :amount,
+              :currency_id,
+              :status,
+              presence: true
+
+    validates :hash,
+              :block_number,
+              presence: { if: -> (t){ t.status.failed? || t.status.success? } }
+
+    validates :txout,
+              presence: { if: -> (t){ t.status.success? } }
+
+    validates :block_number,
+              numericality: { greater_than_or_equal_to: 0, only_integer: true }
+
+    validates :amount,
+              numericality: { greater_than_or_equal_to: 0 }
+
+    validates :fee,
+              numericality: { greater_than_or_equal_to: 0 }, allow_blank: true
+
+    validates :status, inclusion: { in: STATUSES }
+
+    def initialize(attributes={})
+      super
+      @status = @status.present? ? @status.to_s : DEFAULT_STATUS
+    end
+
+    # Status for specific transaction.
+    #
+    # @!method status
+    #
+    # @example
+    #
+    #   status.failed? # true if transaction status 'failed'
+    #   status.success? # true if transaction status 'success'
+    def status
+      @status&.inquiry
+    end
+
+    def status=(s)
+      @status = s.to_s
+    end
+  end
+end

data/lib/innox/upstream/base.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Innox
+  module Upstream
+    class Base
+      DEFAULT_DELAY = 1
+      WEBSOCKET_CONNECTION_RETRY_DELAY = 2
+
+      attr_accessor :logger
+
+      def initialize(config)
+        @host = config["rest"]
+        @adapter = config[:faraday_adapter] || :em_synchrony
+        @config = config
+        @ws_status = false
+        @market = config['source']
+        @target = config['target']
+        @public_trades_cb = []
+        @logger = Innox::Logger.logger
+        @innox_mq = config['amqp']
+        mount
+      end
+
+      def mount
+        @public_trades_cb << method(:on_trade)
+      end
+
+      def ws_connect
+        logger.info { "Websocket connecting to #{@ws_url}" }
+        raise "websocket url missing for account #{id}" unless @ws_url
+
+        @ws = Faye::WebSocket::Client.new(@ws_url)
+
+        @ws.on(:open) do |_e|
+          subscribe_trades(@target, @ws)
+          subscribe_orderbook(@target, @ws)
+          logger.info { "Websocket connected" }
+        end
+
+        @ws.on(:message) do |msg|
+          ws_read_message(msg)
+        end
+
+        @ws.on(:close) do |e|
+          @ws = nil
+          @ws_status = false
+          logger.error "Websocket disconnected: #{e.code} Reason: #{e.reason}"
+          Fiber.new do
+            EM::Synchrony.sleep(WEBSOCKET_CONNECTION_RETRY_DELAY)
+            ws_connect
+          end.resume
+        end
+      end
+
+      def ws_connect_public
+        ws_connect
+      end
+
+      def subscribe_trades(_market, _ws)
+        method_not_implemented
+      end
+
+      def subscribe_orderbook(_market, _ws)
+        method_not_implemented
+      end
+
+      def ws_read_public_message(msg)
+        logger.info { "received public message: #{msg}" }
+      end
+
+      def ws_read_message(msg)
+        logger.debug {"received websocket message: #{msg.data}" }
+
+        object = JSON.parse(msg.data)
+        ws_read_public_message(object)
+      end
+
+      def on_trade(trade)
+        logger.info { "Publishing trade event: #{trade.inspect}" }
+        @innox_mq.enqueue_event("public", @market, "trades", {trades: [trade]})
+        @innox_mq.publish :trade, trade_json(trade), {
+          headers: {
+            type:     :upstream,
+            market:   @market,
+          }
+        }
+      end
+
+      def trade_json(trade)
+        trade.deep_symbolize_keys!
+        {
+          id: trade[:tid],
+          price: trade[:price],
+          amount: trade[:amount],
+          market_id: @market,
+          created_at: Time.at(trade[:date]).utc.iso8601,
+          taker_type: trade[:taker_type]
+        }
+      end
+
+      def notify_public_trade(trade)
+        @public_trades_cb.each {|cb| cb&.call(trade) }
+      end
+
+      def to_s
+        "Exchange::#{self.class} config: #{@opts}"
+      end
+
+      def build_error(response)
+        JSON.parse(response.body)
+      rescue StandardError => e
+        "Code: #{response.env.status} Message: #{response.env.reason_phrase}"
+      end
+    end
+  end
+end

data/lib/innox/upstream/registry.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Innox
+  module Upstream
+    class << self
+      def registry
+        @registry ||= Registry.new
+      end
+
+      class Registry < Innox::AdapterRegistry
+      end
+    end
+  end
+end

data/lib/innox/version.rb

@@ -0,0 +1,3 @@
+module Innox
+  VERSION = "2.7.6"
+end

data/lib/innox/wallet/abstract.rb

@@ -0,0 +1,188 @@
+module Innox
+  module Wallet
+    # @abstract Represents basic wallet interface.
+    #
+    # Subclass and override abstract methods to implement
+    # a innox plugable wallet.
+    # Than you need to register your wallet implementation.
+    #
+    # @see Bitcoin::Wallet Bitcoin as example of Abstract imlementation.
+    #
+    # @example
+    #
+    #   class MyWallet < Innox::Abstract::Wallet
+    #     def create_address(options = {})
+    #       # do something
+    #     end
+    #     ...
+    #   end
+    #
+    #   # Register MyWallet as innox plugable wallet.
+    #   Innox::Wallet.registry[:my_wallet] = MyWallet.new
+    #
+
+    class Abstract
+      # Current wallet settings for performing API calls.
+      #
+      # @abstract
+      #
+      # @!attribute [r] settings
+      # @return [Hash] current wallet settings.
+      attr_reader :settings
+
+      # List of configurable settings.
+      #
+      # @see #configure
+      SUPPORTED_SETTINGS = %i[wallet currency].freeze
+
+      # Hash of features supported by wallet.
+      #
+      # @abstract
+      #
+      # @see Abstract::SUPPORTED_FEATURES for list of features supported by innox.
+      #
+      # @!attribute [r] features
+      # @return [Hash] list of features supported by wallet.
+      attr_reader :features
+
+      # List of features supported by innox.
+      #
+      # @note Features list:
+      #
+      #   skip_deposit_collection - defines if deposit will be collected to 
+      #   hot, warm, cold wallets.
+      SUPPORTED_FEATURES = %i[skip_deposit_collection].freeze
+
+      # Abstract constructor.
+      #
+      # @abstract
+      #
+      # @example
+      #   class MyWallet< Innox::Abstract::Wallet
+      #
+      #     # You could customize your wallet by passing features.
+      #     def initialize(my_custom_features = {})
+      #       @features = my_custom_features
+      #     end
+      #     ...
+      #   end
+      #
+      #   # Register MyWallet as innox plugable wallet.
+      #   custom_features = {cash_addr_format: true}
+      #   Innox::Wallet.registry[:my_wallet] = MyWallet.new(custom_features)
+      def initialize(*)
+        abstract_method
+      end
+
+      # Merges given configuration parameters with defined during initialization
+      # and returns the result.
+      #
+      # @abstract
+      #
+      # @param [Hash] settings configurations to use.
+      # @option settings [Hash] :wallet Wallet settings for performing API calls.
+      # With :address required key other settings could be customized
+      # using Wallet#settings.
+      # @option settings [Array<Hash>] :currencies List of currency hashes
+      #   with :id,:base_factor,:options(deprecated) keys.
+      #   Custom keys could be added by defining them in Currency #options.
+      #
+      # @return [Hash] merged settings.
+      #
+      # @note Be careful with your wallet state after configure.
+      #       Clean everything what could be related to other wallet configuration.
+      #       E.g. client state.
+      def configure(settings = {})
+        abstract_method
+      end
+
+      # Performs API call for address creation and returns it.
+      #
+      # @abstract
+      #
+      # @param [Hash] options
+      # @options options [String] :uid User UID which requested address creation.
+      #
+      # @return [Hash] newly created blockchain address.
+      #
+      # @raise [Innox::Blockchain::ClientError] if error was raised
+      #   on wallet API call.
+      #
+      # @example
+      #   { address: :fake_address,
+      #     secret:  :changeme,
+      #     details: { uid: account.member.uid } }
+      def create_address!(options = {})
+        abstract_method
+      end
+
+      # Performs API call for creating transaction and returns updated transaction.
+      #
+      # @abstract
+      #
+      # @param [Innox::Transaction] transaction transaction with defined
+      # to_address, amount & currency_id.
+      #
+      # @param [Hash] options
+      # @options options [String] :subtract_fee Defines if you need to subtract
+      #   fee from amount defined in transaction.
+      #   It means that you need to deduct fee from amount declared in
+      #   transaction and send only remaining amount.
+      #   If transaction amount is 1.0 and estimated fee
+      #   for sending transaction is 0.01 you need to send 0.09
+      #   so 1.0 (0.9 + 0.1) will be subtracted from wallet balance
+      #
+      # @options options [String] custon options for wallet client.
+      #
+      # @return [Innox::Transaction] transaction with updated hash.
+      #
+      # @raise [Innox::Blockchain::ClientError] if error was raised
+      #   on wallet API call.
+      def create_transaction!(transaction, options = {})
+        abstract_method
+      end
+
+      # Fetches address balance of specific currency.
+      #
+      # @note Optional. Don't override this method if your blockchain
+      # doesn't provide functionality to get balance by address.
+      #
+      # @return [BigDecimal] the current address balance.
+      #
+      # @raise [Innox::Blockchain::ClientError,Innox::Blockchain::UnavailableAddressBalanceError]
+      # if error was raised on wallet API call ClientError is raised.
+      # if wallet API call was successful but we can't detect balance
+      # for address Error is raised.
+      def load_balance!
+        raise Innox::Wallet::UnavailableAddressBalanceError
+      end
+
+      # Performs API call(s) for preparing for deposit collection.
+      # E.g deposits ETH for collecting ERC20 tokens in case of Ethereum blockchain.
+      #
+      # @note Optional. Override this method only if you need additional step
+      # before deposit collection.
+      #
+      # @param [Innox::Transaction] deposit_transaction transaction which
+      # describes received deposit.
+      #
+      # @param [Array<Innox::Transaction>] spread_transactions result of deposit
+      # spread between wallets.
+      #
+      # @return [Array<Innox::Transaction>] transaction created for
+      # deposit collection preparing.
+      # By default return empty [Array]
+      def prepare_deposit_collection!(deposit_transaction, spread_transactions, deposit_currency)
+        # This method is mostly used for coins which needs additional fees
+        # to be deposited before deposit collection.
+        []
+      end
+
+      private
+
+      def abstract_method
+        method_not_implemented
+      end
+    end
+  end
+end

data/lib/innox/wallet/error.rb

@@ -0,0 +1,37 @@
+module Innox
+  module Wallet
+    Error = Class.new(StandardError)
+
+    class ClientError < Error
+
+      attr_reader :wrapped_ex
+
+      def initialize(ex_or_string)
+        @wrapped_ex = nil
+
+        if ex_or_string.respond_to?(:backtrace)
+          super(ex_or_string.message)
+          @wrapped_exception = ex_or_string
+        else
+          super(ex_or_string.to_s)
+        end
+      end
+    end
+
+    class MissingSettingError < Error
+      def initialize(key)
+        super "#{key.capitalize} setting is missing"
+      end
+    end
+
+    class UnavailableAddressBalanceError < Error
+      def initialize(address)
+        @address = address
+      end
+
+      def message
+        "Unable to load #{@address} balance"
+      end
+    end
+  end
+end

data/lib/innox/wallet/registry.rb

@@ -0,0 +1,16 @@
+require "innox/adapter_registry"
+
+module Innox
+  module Wallet
+
+    VERSION = "1.0.0".freeze
+
+    class << self
+      def registry
+        @registry ||= Registry.new
+      end
+    end
+    class Registry < Innox::AdapterRegistry
+    end
+  end
+end