peatio-jruby 2.6.2

data/lib/peatio/ranger/web_socket.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Peatio::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 = Peatio::Auth::JWTAuthenticator.new(jwt_public_key)
+
+    logger = Peatio::Logger.logger
+    logger.info "Starting the server on port #{port}"
+
+    client = Peatio::MQ::Client.new
+    router = Peatio::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
+        Peatio::Logger.logger.info { router.stats }
+        Peatio::Logger.logger.debug { router.debug }
+      end
+    end
+
+    EM::WebSocket.start(host: host, port: port, secure: false) do |socket|
+      connection = Peatio::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(Peatio::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/peatio/security/key_generator.rb

@@ -0,0 +1,26 @@
+require 'fileutils'
+
+module Peatio::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/peatio/sql/client.rb

@@ -0,0 +1,19 @@
+module Peatio::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"] || "peatio_development",
+      }
+    end
+
+    def connect
+      @client = Mysql2::Client.new(config)
+    end
+  end
+end

data/lib/peatio/sql/schema.rb

@@ -0,0 +1,72 @@
+module Peatio::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/peatio/transaction.rb

@@ -0,0 +1,122 @@
+require 'active_support/concern'
+require 'active_support/core_ext/string/inquiry'
+require 'active_support/core_ext/object/blank'
+require 'active_model'
+
+module Peatio #:nodoc:
+
+  # This class represents blockchain transaction.
+  #
+  # Using the instant of this class the peatio application will send/recieve
+  # income/outcome transactions from a peatio pluggable blockchain.
+  #
+  # @example
+  #
+  #   Peatio::Transaction.new(
+  #     {
+  #       hash: '0x5d0ef9697a2f3ea561c9fbefb48e380a4cf3d26ad2be253177c472fdd0e8b486',
+  #       txout: 1,
+  #       to_address: '0x9af4f143cd5ecfba0fcdd863c5ef52d5ccb4f3e5',
+  #       amount: 0.01,
+  #       block_number: 7732274,
+  #       currency_id: 'eth',
+  #       status: 'success'
+  #     }
+  #   )
+  #
+  # @author
+  #   Maksym Naichuk <naichuk.maks@gmail.com> (https://github.com/mnaichuk)
+  class Transaction
+    include ActiveModel::Model
+
+    # List of statuses supported by peatio.
+    #
+    # @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.
+
+    STATUSES = %w[success pending failed].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] 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] 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 :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/peatio/upstream/base.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Peatio
+  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 = Peatio::Logger.logger
+        @peatio_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}" }
+        @peatio_mq.enqueue_event("public", @market, "trades", {trades: [trade]})
+        @peatio_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/peatio/upstream/registry.rb

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

data/lib/peatio/version.rb

@@ -0,0 +1,3 @@
+module Peatio
+  VERSION = "2.6.2"
+end