Feature: Add manual deposit approve

Author: chumaknadya

app/api/v2/admin/deposits.rb

@@ -122,7 +122,7 @@ class Deposits < Grape::API
                    desc: -> { API::V2::Admin::Entities::Refund.documentation[:address][:desc] }
         end
         post '/deposits/:id/refund' do
-          admin_authorize! :wrrie, ::Deposit
+          admin_authorize! :write, ::Deposit
 
           deposit = Deposit.find(params[:id])
 

app/models/deposit.rb

@@ -48,12 +48,16 @@ class Deposit < ApplicationRecord
     state :collected
     state :fee_processing
     state :errored
+    state :refunding
     event(:cancel) { transitions from: :submitted, to: :canceled }
     event(:reject) { transitions from: :submitted, to: :rejected }
     event :accept do
       transitions from: :submitted, to: :accepted
+
       after do
-        if currency.coin? && Peatio::App.config.deposit_funds_locked
+        if currency.coin? && (Peatio::App.config.deposit_funds_locked ||
+                              Peatio::AML.adapter.present? ||
+                              Peatio::App.config.manual_deposit_approval)
           account.plus_locked_funds(amount)
         else
           account.plus_funds(amount)
@@ -66,17 +70,19 @@ class Deposit < ApplicationRecord
     end
 
     event :process do
-      if Peatio::AML.adapter.present?
-        transitions from: %i[aml_processing aml_suspicious accepted errored], to: :aml_processing do
-          after do
-            process_collect! if aml_check!
-          end
+      transitions from: %i[aml_processing aml_suspicious accepted errored], to: :aml_processing do
+        guard do
+          Peatio::AML.adapter.present? || Peatio::App.config.manual_deposit_approval
         end
-      else
-        transitions from: %i[accepted skipped errored], to: :processing do
-          guard { currency.coin? }
+
+        after do
+          process_collect! if aml_check!
         end
       end
+
+      transitions from: %i[accepted skipped errored], to: :processing do
+        guard { currency.coin? }
+      end
     end
 
     event :fee_process do
@@ -91,13 +97,24 @@ class Deposit < ApplicationRecord
 
     event :process_collect do
       transitions from: %i[aml_processing aml_suspicious], to: :processing do
-        guard { currency.coin? }
+        guard do
+          currency.coin? && (Peatio::AML.adapter.present? || Peatio::App.config.manual_deposit_approval)
+        end
+
+        after do
+          if !Peatio::App.config.deposit_funds_locked
+            account.unlock_funds(amount)
+            record_complete_operations!
+          end
+        end
       end
-    end if Peatio::AML.adapter.present?
+    end
 
     event :aml_suspicious do
-      transitions from: :aml_processing, to: :aml_suspicious
-    end if Peatio::AML.adapter.present?
+      transitions from: :aml_processing, to: :aml_suspicious do
+        guard { Peatio::AML.adapter.present? || Peatio::App.config.manual_deposit_approval  }
+      end
+    end
 
     event :dispatch do
       transitions from: %i[processing fee_processing], to: :collected
@@ -117,6 +134,10 @@ class Deposit < ApplicationRecord
   end
 
   def aml_check!
+    # If there is no AML adapter on a platform and manual deposit approval enabled
+    # system will return nil value to not proceed with automatic deposit collection in aml cron job
+    return nil if Peatio::App.config.manual_deposit_approval && Peatio::AML.adapter.blank?
+
     from_addresses.each do |address|
       result = Peatio::AML.check!(address, currency_id, member.uid)
       if result.risk_detected
@@ -225,7 +246,8 @@ def record_submit_operations!
         member_id: member_id
       )
 
-      kind = currency.coin? && Peatio::App.config.deposit_funds_locked ? :locked : :main
+      locked_kind_check = currency.coin? && (Peatio::App.config.deposit_funds_locked || Peatio::App.config.manual_deposit_approval)
+      kind = locked_kind_check ? :locked : :main
       # Credit locked fiat/crypto Liability account.
       Operations::Liability.credit!(
         amount: amount,

app/models/refund.rb

@@ -15,6 +15,7 @@ class Refund < ApplicationRecord
 
     event :process do
       transitions from: :pending, to: :processed
+
       after do
         process_refund!
       end
@@ -26,7 +27,7 @@ class Refund < ApplicationRecord
   end
 
   def process_refund!
-    transaction = WalletService.new(Wallet.deposit.find_by(currency: deposit.currency)).refund!(self)
+    transaction = WalletService.new(Wallet.active_deposit_wallet(deposit.currency.id)).refund!(self)
     deposit.refund! if transaction.present?
   end
 end

app/services/wallet_service.rb

@@ -124,9 +124,24 @@ def deposit_collection_fees!(deposit, deposit_spread)
   end
 
   def refund!(refund)
-    refund_transaction = Peatio::Transaction.new(to_address: refund.address,
-                                                 amount: refund.deposit.amount)
+    @adapter.configure(wallet:   @wallet.to_wallet_api_settings,
+                       currency: refund.deposit.currency.to_blockchain_api_settings)
+
+    pa = PaymentAddress.find_by(wallet_id: @wallet.id, member: refund.deposit.member, address: refund.deposit.address)
+    # NOTE: Deposit wallet configuration is tricky because wallet URI
+    #       is saved on Wallet model but wallet address and secret
+    #       are saved in PaymentAddress.
+    @adapter.configure(
+      wallet: @wallet.to_wallet_api_settings
+                     .merge(pa.details.symbolize_keys)
+                     .merge(address: pa.address)
+                     .tap { |s| s.merge!(secret: pa.secret) if pa.secret.present? }
+                     .compact
+    )
 
+    refund_transaction = Peatio::Transaction.new(to_address: refund.address,
+                                                 amount: refund.deposit.amount,
+                                                 currency_id: refund.deposit.currency_id)
     @adapter.create_transaction!(refund_transaction, subtract_fee: true)
   end
 

config/initializers/config.rb

@@ -4,4 +4,5 @@
 
 Peatio::App.define do |config|
   config.set(:deposit_funds_locked, 'false', type: :bool)
+  config.set(:manual_deposit_approval, 'false', type: :bool)
 end

spec/models/deposit_spec.rb

@@ -172,6 +172,34 @@
           end
         end
 
+        context 'with manual deposit approval' do
+          before { Peatio::App.config.stubs(:manual_deposit_approval).returns(true) }
+          context 'credits both legacy and operations based member balance for coin deposit' do
+            subject { create(:deposit_btc, amount: 3.7) }
+
+            it do
+              subject.accept!
+              %i[main locked].each do |kind|
+                expect(
+                  subject.member.balance_for(currency: subject.currency, kind: kind)
+                ).to eq(
+                  subject.member.legacy_balance_for(currency: subject.currency, kind: kind)
+                )
+              end
+
+              expect(subject.member.balance_for(currency: subject.currency, kind: :locked)).to eq 3.7
+              expect(subject.member.balance_for(currency: subject.currency, kind: :main)).to eq 0
+
+              # Lock funds on deposit accepted step (1 liability)
+              liabilities = Operations::Liability.where(currency_id: subject.currency.id, member_id: subject.member.id, reference_type: 'Deposit')
+              expect(liabilities.count).to eq 1
+
+              account = Operations::Account.find_by(kind: :locked, currency_type: subject.currency.type, type: 'liability', scope: 'member')
+              expect(liabilities.first.code).to eq account.code
+            end
+          end
+        end
+
         context 'with locked funds' do
           before { Peatio::App.config.stubs(:deposit_funds_locked).returns(true) }
           context 'credits both legacy and operations based member balance for coin deposit' do
@@ -204,18 +232,118 @@
   end
 
   context :process do
-    let(:crypto_deposit) { create(:deposit_btc, amount: 3.7) }
+    context 'fiat deposit' do
+      it 'doesnt process fiat deposit' do
+        deposit.accept!
+        expect(deposit.process!).to eq false
+      end
+    end
+
+    context 'coin deposit' do
+      context 'automatic process' do
+        context 'coin deposit' do
+          subject { create(:deposit_btc, amount: 3.7) }
+          it 'process coin deposit' do
+            crypto_deposit = create(:deposit_btc, amount: 3.7)
+            crypto_deposit.accept!
+            expect(crypto_deposit.process!).to eq true
+            expect(crypto_deposit.processing?).to eq true
+          end
+        end
+      end
 
-    it 'doesnt process fiat deposit' do
-      deposit.accept!
-      expect(deposit.process!).to eq false
+      context 'manual process' do
+        before do
+          Peatio::App.config.stubs(:manual_deposit_approval).returns(true)
+        end
+
+        subject { create(:deposit_btc, amount: 3.7) }
+
+        it do
+          subject.accept!
+          subject.process!
+
+          expect(subject.aml_processing?).to eq true
+        end
+      end
     end
+  end
 
-    it 'process coin deposit' do
-      crypto_deposit = create(:deposit_btc, amount: 3.7)
-      crypto_deposit.accept!
-      expect(crypto_deposit.process!).to eq true
-      expect(crypto_deposit.processing?).to eq true
+  context 'process collect' do
+    let(:crypto_deposit) { create(:deposit_btc, amount: 3.7) }
+
+    subject { crypto_deposit }
+
+    context 'with manual deposit approval' do
+      context 'deposit_funds_locked disabled' do
+        before do
+          Peatio::App.config.stubs(:manual_deposit_approval).returns(true)
+          crypto_deposit.accept!
+          crypto_deposit.process!
+        end
+
+        it 'process deposit collection' do
+          crypto_deposit.process_collect!
+
+          expect(crypto_deposit.processing?).to eq true
+
+          %i[main locked].each do |kind|
+            expect(
+              subject.member.balance_for(currency: subject.currency, kind: kind)
+            ).to eq(
+              subject.member.legacy_balance_for(currency: subject.currency, kind: kind)
+            )
+
+            liabilities = Operations::Liability.where(currency_id: subject.currency.id, member_id: subject.member.id)
+            expect(liabilities.count).to eq 3
+
+            # Lock funds on deposit accepted step (1 liability)
+            account = Operations::Account.find_by(kind: :locked, currency_type: subject.currency.type, type: 'liability', scope: 'member')
+            expect(liabilities.first.code).to eq account.code
+
+            # Moved funds from locked to main (2 liabilities)
+            # debit
+            account = Operations::Account.find_by(kind: :locked, currency_type: subject.currency.type, type: 'liability', scope: 'member')
+            expect(liabilities.second.code).to eq account.code
+
+            # credit
+            account = Operations::Account.find_by(kind: :main, currency_type: subject.currency.type, type: 'liability', scope: 'member')
+            expect(liabilities.last.code).to eq account.code
+          end
+        end
+      end
+
+      context 'deposit_funds_locked enabled' do
+        before do
+          Peatio::App.config.stubs(:deposit_funds_locked).returns(true)
+          crypto_deposit.accept!
+          crypto_deposit.process!
+        end
+
+        it 'process deposit collection' do
+          crypto_deposit.process_collect!
+
+          expect(crypto_deposit.processing?).to eq true
+
+          %i[main locked].each do |kind|
+            expect(
+              subject.member.balance_for(currency: subject.currency, kind: kind)
+            ).to eq(
+              subject.member.legacy_balance_for(currency: subject.currency, kind: kind)
+            )
+          end
+
+          expect(subject.member.balance_for(currency: subject.currency, kind: :locked)).to eq 3.7
+          expect(subject.member.balance_for(currency: subject.currency, kind: :main)).to eq 0
+
+          # Lock funds on deposit accepted step (1 liability)
+          liabilities = Operations::Liability.where(currency_id: subject.currency.id, member_id: subject.member.id, reference_type: 'Deposit')
+          expect(liabilities.count).to eq 1
+
+          account = Operations::Account.find_by(kind: :locked, currency_type: subject.currency.type, type: 'liability', scope: 'member')
+          expect(liabilities.first.code).to eq account.code
+        end
+      end
     end
   end
 

spec/services/wallet_service_spec.rb

@@ -819,4 +819,42 @@
       end
     end
   end
+
+  context :refund do
+    before do
+      Peatio::Blockchain.registry.expects(:[])
+                        .with(:bitcoin)
+                        .returns(fake_blockchain_adapter.class)
+                        .at_least_once
+    end
+
+    let!(:deposit_wallet) { create(:wallet, :fake_deposit) }
+
+    let(:amount) { 2 }
+    let(:refund_deposit) { create(:deposit_btc, amount: amount, currency: currency) }
+
+    let(:fake_wallet_adapter) { FakeWallet.new }
+    let(:service) { WalletService.new(deposit_wallet) }
+
+    let(:transaction) do
+      Peatio::Transaction.new(hash:        '0xfake',
+                               to_address:  'user_address',
+                               amount:      refund_deposit.amount,
+                               currency_id: currency.id)
+    end
+
+    let!(:refund) { Refund.create(deposit: refund_deposit, address: 'user_address') }
+
+    subject { service.refund!(refund) }
+
+    before do
+      refund_deposit.member.payment_address(service.wallet.id).update(address: refund_deposit.address)
+      service.adapter.expects(:create_transaction!).returns(transaction)
+    end
+
+    it 'creates single transaction' do
+      expect(subject).to eq(transaction)
+      expect(subject).to be_a(Peatio::Transaction)
+    end
+  end
 end