abax_contracts 1.0.0

Contracts for the Abax Protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

// SPDX-License-Identifier: BUSL-1.1
use super::{_check_amount_not_zero, storage::LendingPoolStorage};
use crate::{
    abacus_token::{AbacusToken, AbacusTokenRef, TransferEventData},
    lending_pool::{
        events::{Deposit, Withdraw},
        LendingPoolError,
    },
};
use ink::codegen::TraitCallBuilder;
use ink::{env::DefaultEnvironment, prelude::*};
use pendzl::{
    contracts::access_control::AccessControlError,
    traits::{AccountId, Balance, StorageFieldGetter},
};

pub trait LendingPoolATokenInterfaceImpl:
    StorageFieldGetter<LendingPoolStorage>
{
    fn total_deposit_of(&self, underlying_asset: AccountId) -> Balance {
        let timestamp = Self::env().block_timestamp();
        self.data::<LendingPoolStorage>()
            .total_deposit_of(&underlying_asset, &timestamp)
            .unwrap()
    }

    fn account_deposit_of(
        &self,
        underlying_asset: AccountId,
        account: AccountId,
    ) -> Balance {
        let timestamp = Self::env().block_timestamp();
        self.data::<LendingPoolStorage>()
            .account_deposit_of(&underlying_asset, &account, &timestamp)
            .unwrap()
    }

    fn transfer_deposit_from_to(
        &mut self,
        underlying_asset: AccountId,
        from: AccountId,
        to: AccountId,
        amount: Balance,
    ) -> Result<(Balance, Balance), LendingPoolError> {
        _check_amount_not_zero(amount)?;

        let reserve_abacus_tokens_tokens = self
            .data::<LendingPoolStorage>()
            .reserve_abacus_tokens
            .get(underlying_asset)
            .ok_or(LendingPoolError::AssetNotRegistered)?;
        if Self::env().caller() != reserve_abacus_tokens_tokens.a_token_address
        {
            return Err((AccessControlError::MissingRole).into());
        }

        let timestamp = Self::env().block_timestamp();
        let (
            (from_accumulated_deposit_interest, from_accumulated_debt_interest),
            (to_accumulated_deposit_interest, to_accumulated_debt_interest),
        ) = self
            .data::<LendingPoolStorage>()
            .account_for_deposit_transfer_from_to(
                &underlying_asset,
                &from,
                &to,
                &amount,
                &timestamp,
            )?;

        // check if there ie enought collateral
        self.data::<LendingPoolStorage>()
            .ensure_collateralized_by_account(&from)?;

        //// ABACUS TOKEN EVENTS
        // AToken interests are returned.
        // VToken intersts
        if from_accumulated_debt_interest != 0
            || to_accumulated_debt_interest != 0
        {
            let mut abacus_token_contract: AbacusTokenRef =
                reserve_abacus_tokens_tokens.v_token_address.into();

            abacus_token_contract
                .call_mut()
                .emit_transfer_events(vec![
                    TransferEventData {
                        from: None,
                        to: Some(from),
                        amount: from_accumulated_debt_interest,
                    },
                    TransferEventData {
                        from: None,
                        to: Some(to),
                        amount: to_accumulated_debt_interest,
                    },
                ])
                .call_v1()
                .invoke()?;
        }

        //// EVENT
        ink::env::emit_event::<DefaultEnvironment, Deposit>(Deposit {
            asset: underlying_asset,
            caller: Self::env().caller(),
            on_behalf_of: to,
            amount,
        });
        ink::env::emit_event::<DefaultEnvironment, Withdraw>(Withdraw {
            asset: underlying_asset,
            caller: Self::env().caller(),
            on_behalf_of: from,
            amount,
        });

        Ok((
            from_accumulated_deposit_interest,
            to_accumulated_deposit_interest,
        ))
    }
}