taunchpad 3.1.0

data/app/controllers/launchpad/api/v2/public/base_controller.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Launchpad
+  module API
+    module V2
+      module Public
+        class BaseController < ApplicationController
+        end
+      end
+    end
+  end
+end

data/app/controllers/launchpad/api/v2/public/ieo/sales_controller.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_dependency "launchpad/api/v2/public/base_controller"
+module Launchpad
+  module API
+    module V2
+      module Public
+        module IEO
+          class SalesController < BaseController
+            def index
+              ransack_params = {
+                state_in:       params[:state],
+                currency_id_eq: params[:currency_id],
+                name_cont_all:  params[:name]
+              }
+
+              sales = Launchpad::IEO::Sale.public_states.order(created_at: (params[:ordering] || :asc))
+                                                        .ransack(ransack_params)
+
+              json_response(paginate(sales.result), 200)
+            end
+
+            def show
+              launchpad = Launchpad::IEO::Sale.find(params[:id])
+              additional_params = {
+                  generic_bids: launchpad.orders.where("state = ? OR state = ?", 'active', 'completed').last(50).as_json(uid: true),
+              }
+              json_response(launchpad.as_json.merge(additional_params), 200)
+            end
+
+            def search
+              ransack_params = {
+                  state_in:       params[:state],
+                  currency_id_eq: params[:currency_id],
+                  name_cont_all:  params[:name]
+              }
+
+              sales = Launchpad::IEO::Sale.includes(:pairs)
+                          .public_states.order(Arel.sql("CASE state
+                                                         WHEN 'ongoing' THEN '1'
+                                                         WHEN 'preparing' THEN '2'
+                                                         WHEN 'distributing' THEN '3'
+                                                         WHEN 'refunding' THEN '4'
+                                                         WHEN 'finished' THEN '5'
+                                                         WHEN 'cancelled' THEN '6'
+                                                         END")).order(created_at: :desc)
+                          .ransack(ransack_params)
+
+              json_response(paginate(sales.result).map(&:sales_to_json), 200)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/launchpad/application_controller.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Launchpad
+  class ApplicationController < ActionController::Base
+    skip_before_action :verify_authenticity_token
+    include Rails::Pagination
+    include Response
+    include ExceptionHandlers
+  end
+end

data/app/helpers/launchpad/application_helper.rb

@@ -0,0 +1,4 @@
+module Launchpad
+  module ApplicationHelper
+  end
+end

data/app/models/launchpad/application_record.rb

@@ -0,0 +1,5 @@
+module Launchpad
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/launchpad/ieo.rb

@@ -0,0 +1,21 @@
+module Launchpad
+  module IEO
+    TOKENS_AMOUNT_PRECISION = 4
+    RATIO_PRECISION = 4
+    COMMISSION_PRECISION = 6
+
+    LIABILITY_CODES = {
+      fiat: { main: 201, locked: 211 },
+      coin: { main: 202, locked: 212 }
+    }
+
+    REVENUE_CODES = {
+      fiat: { main: 301 },
+      coin: { main: 302 }
+    }
+
+    def self.table_name_prefix
+      'ieo_'
+    end
+  end
+end

data/app/models/launchpad/ieo/order.rb

@@ -0,0 +1,576 @@
+# frozen_string_literal: true
+
+module Launchpad
+  module IEO
+    # TODO: Add validation that orders are created only for ongoing sales.
+    # TODO: Add attr_readonly for all models.
+    class Order < ApplicationRecord
+      # == Constants ============================================================
+
+      include AASM
+
+      # == Attributes ===========================================================
+
+      # == Extensions ===========================================================
+
+      serialize :transfer_keys, Array
+
+      # NOTE: We use pessimistic locking for avoiding double transfer creation.
+      aasm requires_lock: true, column: :state do
+        state :preparing, initial: true
+        state :rejected
+        state :active
+        state :refunding
+        state :closed
+        state :cancelled
+        state :executing
+        state :completed
+        state :releasing
+        state :purchased
+
+        # Events docs:
+        # preparing -> active;
+        # preparing -> rejected;
+        # active -> executing;
+        # active -> refunfing;
+        # active -> cancelled;
+        # exucuting -> purchased;
+        # executing -> completed;
+        # executing -> refunding;
+        # executing -> cancelled;
+        # purchased -> releasing;
+        # releasing -> completed;
+        # refunding -> closed;
+
+        # dispatch! => preparing -> active;
+        #
+        # reject! => preparing -> rejected;
+        #
+        # execute! => active -> executing;
+        #
+        #               - => executing -> purchased;
+        #             /
+        # purchase! - - => executing -> completed;
+        #             \
+        #               - => executing -> refunding;
+        #
+        # refund! => active -> refunding;
+        #
+        # release! => purchased -> releasing;
+        #
+        # unlock! => releasing -> completed;
+        #
+        # close! => refunding -> closed;
+        #
+        #               - => executing -> cancelled;
+        #             /
+        # cancel! -  |
+        #             \
+        #               - => active -> cancelled;
+        #
+
+        event :dispatch do
+          transitions from: :preparing, to: :active do
+            after do
+              perform_transfer(lock_transfer_params)
+            end
+          end
+          after_commit do
+            sale.notify_ranger
+            execute! if sale.type.fcfs?
+          end
+        end
+
+        event :reject do
+          transitions from: :preparing, to: :rejected
+        end
+
+        event :execute, after_commit: :enqueue_execute_job do
+          transitions from: :active, to: :executing
+        end
+
+        event :purchase do
+          transitions from: :executing, to: :purchased do
+            guard do
+              calculate_share
+              sale.lockup_percentage.positive?
+            end
+            after do
+              perform_transfer(execute_transfer_params)
+            end
+          end
+
+          transitions from: :executing, to: :completed do
+            guard do
+              calculate_share
+              sale.lockup_percentage.zero?
+            end
+            after do
+              perform_transfer(execute_transfer_params)
+            end
+          end
+
+          transitions from: :executing, to: :refunding
+
+          after_commit do
+            sale.finish! if sale.type.fcfs? && sale.full?
+            enqueue_refund_job if refunding?
+          end
+        end
+
+        event :refund do
+          transitions from: :active, to: :refunding
+
+          after_commit do
+            enqueue_refund_job
+          end
+        end
+
+        event :release do
+          transitions from: :purchased, to: :releasing
+
+          after_commit do
+            enqueue_released_job
+          end
+        end
+
+        event :unlock do
+          transitions from: :releasing, to: :completed do
+            after do
+              perform_transfer(release_transfer_params)
+              calculate_release
+            end
+          end
+        end
+
+        event :close do
+          transitions from: :refunding, to: :closed do
+            after do
+              calculate_refunded
+              perform_transfer(cancel_transfer_params)
+            end
+          end
+        end
+
+        event :cancel do
+          transitions from: :executing, to: :cancelled do
+            after do
+              calculate_refund
+              Rails.logger.info("Transition from executing to cancelled")
+              perform_transfer(cancel_transfer_params)
+            end
+          end
+
+          transitions from: :active, to: :cancelled do
+            after do
+              calculate_refund
+              Rails.logger.info("Transition from active to cancelled")
+              perform_transfer(cancel_transfer_params)
+            end
+          end
+
+          after_commit do
+            sale.notify_ranger
+          end
+        end
+      end
+
+      # == Relationships ========================================================
+
+      belongs_to :sale_pair, class_name: "Launchpad::IEO::SalePair", required: true
+
+      has_one :sale, class_name: "Launchpad::IEO::Sale", through: :sale_pair
+
+      # == Validations ==========================================================
+
+      validates :uid, :contribution, :executed, :refunded, :tokens_received,
+                :commission_rate, :commission_amount, :state, presence: {
+                  message: ->(_, _data) { "missing_" }
+                }
+
+      validates :contribution,
+                numericality: {
+                  greater_than: 0,
+                  message:      ->(_, _data) { "non_positive_" }
+                }
+
+      validates :executed, :refunded, :tokens_received,
+                :commission_rate, :commission_amount,
+                numericality: {
+                  greater_than_or_equal_to: 0,
+                  message:                  ->(_, _data) { "negative_" }
+                }
+
+      validates :tokens_ordered,
+                numericality: {
+                  greater_than_or_equal_to: ->(order) { order.sale.min_amount },
+                  message:                  ->(_, _data) { "_less_than_min_amount" }
+                }
+
+      validates :tokens_ordered,
+                numericality: {
+                  less_than_or_equal_to: ->(order) { order.sale.max_amount - order.sale.orders.active_and_prepared.where(uid: order.uid).tokens_ordered },
+                  message:               ->(_, _data) { "_greater_than_max_amount" }
+                }, if: ->(order) { order.sale.type.proportional? },
+                on: :create
+
+      validates :tokens_ordered,
+                numericality: {
+                  less_than_or_equal_to: ->(order) { order.sale.max_amount - order.sale.orders.active_and_prepared_and_completed.where(uid: order.uid).tokens_ordered },
+                  message:               ->(_, _data) { "_greater_than_max_amount" }
+                }, if: ->(order) { order.sale.type.fcfs? },
+                on: :create
+
+      validates :tokens_ordered,
+                numericality: {
+                  less_than_or_equal_to: ->(order) { order.sale.supply - order.sale.orders.executable.tokens_ordered },
+                  message:               ->(_, _) { "_greater_than_sale_supply" }
+                }, if: ->(order) { order.sale.type.fcfs? },
+                on: :create
+
+      # == Scopes ===============================================================
+
+      scope :active_and_prepared, -> { where(state: %i[active preparing]) }
+
+      scope :active_and_prepared_and_completed, -> { where(state: %i[active preparing purchased completed]) }
+
+      # Scope represents all orders which may be executed.
+      # So this orders influence tokens_ordered and ratio.
+      scope :executable, -> { where(state: %i[preparing active executing purchased completed]) }
+
+      # == Callbacks ============================================================
+
+      before_validation(on: :create) { self.commission_rate = sale.commission }
+
+      # == Class Methods ========================================================
+
+      class << self
+        def tokens_ordered(ndigits: Launchpad::IEO::TOKENS_AMOUNT_PRECISION)
+          # Include SalePair for accessing price.
+          if first&.add?
+            all.includes(:sale_pair).sum("contribution / ieo_sale_pairs.price").round(ndigits).to_d
+          else
+            all.includes(:sale_pair).sum("(1 - commission_rate) * contribution / ieo_sale_pairs.price").round(ndigits).to_d
+          end
+        end
+
+        def release_fund(percent = 0)
+          return if percent.to_d == 0
+
+          all.each do |order|
+            next unless order.tokens_locked.positive?
+
+            funds = (order.tokens_locked + order.tokens_received) * percent.to_d
+            order.perform_transfer(order.release_funds_params(funds))
+            order.tokens_locked   -= funds
+            order.tokens_received += funds
+            order.save!
+          end
+        end
+      end
+
+      # == Instance Methods =====================================================
+
+      delegate :price, to: :sale_pair
+
+      def as_json(_options={})
+        if _options[:uid]
+          super(except:  [:transfer_keys, :uid],
+            methods: %i[tokens_ordered base_currency quote_currency ratio sale_name]).merge(sale_id: sale.id)
+        else
+          super(except:  :transfer_keys,
+            methods: %i[tokens_ordered base_currency quote_currency ratio sale_name]).merge(sale_id: sale.id)
+        end
+      end
+
+      def tokens_ordered(ndigits: Launchpad::IEO::TOKENS_AMOUNT_PRECISION)
+        if add?
+          (contribution / price).round(ndigits)
+        else
+          ((1 - commission_rate) * contribution / price).round(ndigits)
+        end
+      end
+
+      def executed_without_commission
+        add? ? executed : executed - commission_amount
+      end
+
+      def sale_name
+        sale.name
+      end
+
+      def base_currency
+        sale.currency_id
+      end
+
+      def quote_currency
+        sale_pair.quote_currency_id
+      end
+
+      def ratio
+        sale_ratio = sale.ratio < 1 ? 1 : sale.ratio
+        (1 / sale_ratio).to_d.round(Launchpad::IEO::RATIO_PRECISION, BigDecimal::ROUND_DOWN)
+      end
+
+      def calculate_share
+        self.executed = contribution * ratio
+        self.refunded = contribution - executed
+
+        self.commission_amount = executed * commission_rate
+
+        tokens_ordered = (executed_without_commission / sale_pair.price).round(Launchpad::IEO::TOKENS_AMOUNT_PRECISION, BigDecimal::ROUND_DOWN)
+        self.tokens_locked = tokens_ordered * sale.lockup_percentage.to_d
+        self.tokens_received = tokens_ordered * (1 - sale.lockup_percentage.to_d)
+      end
+
+      def calculate_refund
+        # This logic may become complex later.
+        self.refunded = calculate_contribution
+      end
+
+      def calculate_refunded
+        self.refunded = contribution - executed
+        self.refunded = calculate_execute_refunded
+      end
+
+      def add?
+        sale.fees_policy.add?
+      end
+
+      def calculate_contribution
+        add? ? contribution + contribution * commission_rate : contribution
+      end
+
+      def calculate_release
+        self.tokens_received += tokens_locked 
+        self.tokens_locked = 0
+      end
+
+      def lock_transfer_params
+        type = fetch_currency(sale_pair.quote_currency_id)
+                .fetch(:type)
+                .to_sym
+
+        operations =
+          [
+            {
+              currency:    sale_pair.quote_currency_id,
+              amount:      calculate_contribution,
+              account_src: {code: Launchpad::IEO::LIABILITY_CODES[type][:main],   uid: uid},
+              account_dst: {code: Launchpad::IEO::LIABILITY_CODES[type][:locked], uid: uid}
+            }
+          ].delete_if { |op| op[:amount].zero? }
+
+        {
+          key:         "IEO-lock-#{id}",
+          category:    "purchases",
+          description: "Lock funds for IEO order #{id}",
+          operations:  operations
+        }
+      end
+
+      def execute_transfer_params
+        base_currency_type = fetch_currency(sale.currency_id)
+                              .fetch(:type)
+                              .to_sym
+        quote_currency_type = fetch_currency(sale_pair.quote_currency_id)
+                              .fetch(:type)
+                              .to_sym
+
+        operations =
+          [
+            { # Debit seller main liabilities & credit user locked liabilities with base currency.
+              currency:    sale.currency_id,
+              amount:      tokens_locked,
+              account_src: {code: Launchpad::IEO::LIABILITY_CODES[base_currency_type][:main],
+                            uid:  sale.owner_uid},
+              account_dst: {code: Launchpad::IEO::LIABILITY_CODES[base_currency_type][:locked],
+                            uid:  uid}
+            },
+            { # Debit seller main liabilities & credit user main liabilities with base currency.
+              currency:    sale.currency_id,
+              amount:      tokens_received,
+              account_src: {code: Launchpad::IEO::LIABILITY_CODES[base_currency_type][:main],
+                            uid:  sale.owner_uid},
+              account_dst: {code: Launchpad::IEO::LIABILITY_CODES[base_currency_type][:main],
+                            uid:  uid}
+            },
+            { # Debit user locked liabilities & credit seller main liabilities with quote currency.
+              currency:    sale_pair.quote_currency_id,
+              amount:      executed_without_commission,
+              account_src: {code: Launchpad::IEO::LIABILITY_CODES[quote_currency_type][:locked],
+                            uid:  uid},
+              account_dst: {code: Launchpad::IEO::LIABILITY_CODES[quote_currency_type][:main],
+                            uid:  sale.owner_uid}
+            },
+            { # Debit user locked liabilities & credit user main liabilities with quote currency.
+              currency:    sale_pair.quote_currency_id,
+              amount:      calculate_execute_refunded,
+              account_src: {code: Launchpad::IEO::LIABILITY_CODES[quote_currency_type][:locked],
+                            uid:  uid},
+              account_dst: {code: Launchpad::IEO::LIABILITY_CODES[quote_currency_type][:main],
+                            uid:  uid}
+            },
+            { # Debit user locked liabilities & credit main revenues with quote currency.
+              currency:    sale_pair.quote_currency_id,
+              amount:      commission_amount,
+              account_src: {code: Launchpad::IEO::LIABILITY_CODES[quote_currency_type][:locked],
+                            uid:  uid},
+              account_dst: {code: Launchpad::IEO::REVENUE_CODES[quote_currency_type][:main]}
+            }
+          ].delete_if { |op| op[:amount].zero? }
+
+        {
+          key:         "IEO-execute-#{id}",
+          category:    :purchases,
+          description: "Execute IEO order #{id}",
+          operations:  operations
+        }
+      end
+
+      def calculate_execute_refunded
+        add? ? refunded + refunded * commission_rate : refunded
+      end
+
+      def release_transfer_params
+        base_currency_type = fetch_currency(sale.currency_id)
+                              .fetch(:type)
+                              .to_sym
+
+        operations =
+          [
+            { # Debit user locked liabilities & credit user main liabilities with base currency.
+              currency:    sale.currency_id,
+              amount:      tokens_locked,
+              account_src: {code: Launchpad::IEO::LIABILITY_CODES[base_currency_type][:locked],
+                            uid:  uid},
+              account_dst: {code: Launchpad::IEO::LIABILITY_CODES[base_currency_type][:main],
+                            uid:  uid}
+            }
+          ].delete_if { |op| op[:amount].zero? }
+
+        {
+          key:         "IEO-release-#{id}",
+          category:    :purchases,
+          description: "Release IEO order #{id}",
+          operations:  operations
+        }
+      end
+
+      def cancel_transfer_params
+        quote_currency_type = fetch_currency(sale_pair.quote_currency_id)
+                              .fetch(:type)
+                              .to_sym
+
+        operations =
+          [
+            { # Debit user locked liabilities & credit user main liabilities with quote currency.
+              currency:    sale_pair.quote_currency_id,
+              amount:      refunded,
+              account_src: {code: Launchpad::IEO::LIABILITY_CODES[quote_currency_type][:locked],
+                            uid:  uid},
+              account_dst: {code: Launchpad::IEO::LIABILITY_CODES[quote_currency_type][:main],
+                            uid:  uid}
+            }
+          ]
+        if add?
+          # Debit user locked liabilities & credit main revenues with quote currency.
+          operations << {
+            currency:    sale_pair.quote_currency_id,
+            amount:      commission_amount,
+            account_src: {code: Launchpad::IEO::LIABILITY_CODES[quote_currency_type][:locked],
+                          uid: uid},
+            account_dst: {code: Launchpad::IEO::REVENUE_CODES[quote_currency_type][:main]}
+          }
+        end
+
+        operations.delete_if { |op| op[:amount].zero? }
+
+        {
+          key:         "IEO-cancel-#{id}",
+          category:    :purchases,
+          description: "Cancel IEO order #{id}",
+          operations:  operations
+        }
+      end
+
+      def release_funds_params(funds)
+        base_currency_type = fetch_currency(sale.currency_id)
+                               .fetch(:type)
+                               .to_sym
+        operations =
+            [
+              { # Debit user locked liabilities & credit user main liabilities with base currency.
+                currency:    sale.currency_id,
+                amount:      funds,
+                account_src: {code: Launchpad::IEO::LIABILITY_CODES[base_currency_type][:locked],
+                              uid:  uid},
+                account_dst: {code: Launchpad::IEO::LIABILITY_CODES[base_currency_type][:main],
+                              uid:  uid}
+              }
+            ].delete_if { |op| op[:amount].zero? }
+
+        {
+            key:         generate_key,
+            category:    :purchases,
+            description: "Release IEO order locked funds #{id}",
+            operations:  operations
+        }
+      end
+
+      def generate_key
+        "IEO-fund-release-#{id}-#{transfer_keys.grep(/IEO-fund-release-/).size}"
+      end
+
+      def perform_transfer(transfer_params)
+        Peatio::ManagementAPIV2::Client.new.create_transfer(transfer_params)
+        transfer_keys << transfer_params[:key]
+      end
+
+      def enqueue_execute_job
+        Launchpad::IEO::OrderExecuteWorker.perform_async(to_sgid(for: "order_execute"))
+      end
+
+      def enqueue_released_job
+        Launchpad::IEO::OrderReleaseWorker.perform_async(to_sgid(for: "order_release"))
+      end
+
+      def enqueue_refund_job
+        Launchpad::IEO::OrderRefundWorker.perform_async(to_sgid(for: "order_refund"))
+      end
+
+      private
+
+      # TODO: Move this method to helper or somewhere else.
+      def fetch_currency(code)
+        Rails.cache.fetch("currency_#{code}", expires_in: 1.day) do
+          Peatio::ManagementAPIV2::Client.new.currency(code: code)
+        end
+      end
+    end
+  end
+end
+
+# == Schema Information
+# Schema version: 20191001145525
+#
+# Table name: ieo_orders
+#
+#  id                :bigint           not null, primary key
+#  sale_pair_id      :bigint           not null
+#  uid               :string(255)      not null
+#  contribution      :decimal(32, 16)  not null
+#  executed          :decimal(32, 16)  default(0.0), not null
+#  refunded          :decimal(32, 16)  default(0.0), not null
+#  tokens_received   :decimal(32, 16)  default(0.0), not null
+#  commission_rate   :decimal(16, 16)  default(0.0), not null
+#  commission_amount :decimal(32, 16)  default(0.0), not null
+#  transfer_keys     :string(1000)
+#  state             :string(32)       not null
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#
+# Indexes
+#
+#  index_ieo_orders_on_sale_pair_id  (sale_pair_id)
+#