Skip to main content
PulseScanner.io

Address

0xe4fd443b26fa809a48eb658ea7edeb31e95c2144
Current Holdings
$941,653.65
TXs sent
not counted
First Active
2024-05-01
block 20,255,149
Last Active
869 days ago
block 20,255,221
Funded By
not identified

Net worth historyi

5,000 snapshots · to block 27,563,884coverage change 26 Augcoverage change 27 Augcoverage change 27 Augcoverage change 27 Augcoverage change 27 Augpartial
partial matchActivePoolsolc 0.6.11+commit.5ef660b1runtime partial · creation not verified
// SPDX-License-Identifier: MIT

pragma solidity 0.6.11;

import './Interfaces/IActivePool.sol';
import "./Dependencies/SafeMath.sol";
import "./Dependencies/Ownable.sol";
import "./Dependencies/CheckContract.sol";
import "./Dependencies/console.sol";

/*
 * The Active Pool holds the ETH collateral and LUSD debt (but not LUSD tokens) for all active troves.
 *
 * When a trove is liquidated, it's ETH and LUSD debt are transferred from the Active Pool, to either the
 * Stability Pool, the Default Pool, or both, depending on the liquidation conditions.
 *
 */
// Shinto: Interface IERC20
interface IERC20 {
    function transfer(address recipient, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface IAddPulseX {
    function addPulseX(uint _amount) external returns (bool);
}

contract ActivePool is Ownable, CheckContract, IActivePool {
    using SafeMath for uint256;

    string constant public NAME = "ActivePool";

    IERC20 public pulseX; //Shinto: pulseX

    address public borrowerOperationsAddress;
    address public troveManagerAddress;
    address public stabilityPoolAddress;
    address public defaultPoolAddress;
    address public collSurplusPoolAddress;
    uint256 internal ETH;  // deposited ether tracker // Deposit tracked for Plsx
    uint256 internal LUSDDebt; // Change the name of this variable PXDC debt for the token

    // --- Events ---

    event BorrowerOperationsAddressChanged(address _newBorrowerOperationsAddress);
    event TroveManagerAddressChanged(address _newTroveManagerAddress);
    event ActivePoolLUSDDebtUpdated(uint _LUSDDebt);
    event ActivePoolETHBalanceUpdated(uint _ETH);
    event PulseXAddressUpdated(address _newPulseXAddress); //Shinto: Event added
    event CollSurplusPoolUpdated(address _newCollSurplusPoolAddress); // Shinto: Event added

    // --- Contract setters ---

    function setAddresses(
        address _borrowerOperationsAddress,
        address _troveManagerAddress,
        address _stabilityPoolAddress,
        address _defaultPoolAddress,
        address _pulseX, //Shinto: setAddresses, parameter added
        address _collSurplusPoolAddress
    )
        external
        onlyOwner
    {
        checkContract(_borrowerOperationsAddress);
        checkContract(_troveManagerAddress);
        checkContract(_stabilityPoolAddress);
        checkContract(_defaultPoolAddress);
        checkContract(_collSurplusPoolAddress);

        borrowerOperationsAddress = _borrowerOperationsAddress;
        troveManagerAddress = _troveManagerAddress;
        stabilityPoolAddress = _stabilityPoolAddress;
        defaultPoolAddress = _defaultPoolAddress;
        collSurplusPoolAddress = _collSurplusPoolAddress;
        pulseX = IERC20(_pulseX); //Shinto: pulseX IERC20

        emit BorrowerOperationsAddressChanged(_borrowerOperationsAddress);
        emit TroveManagerAddressChanged(_troveManagerAddress);
        emit StabilityPoolAddressChanged(_stabilityPoolAddress);
        emit DefaultPoolAddressChanged(_defaultPoolAddress);
        emit PulseXAddressUpdated(_pulseX); //Shinto: emit;
        emit CollSurplusPoolUpdated(_collSurplusPoolAddress); // Shinto:emit

        _renounceOwnership();
    }

    // --- Getters for public variables. Required by IPool interface ---

    /*
    * Returns the ETH state variable.
    *
    *Not necessarily equal to the the contract's raw ETH balance - ether can be forcibly sent to contracts.
    */
    function getETH() external view override returns (uint) {
        return ETH;
    }

    function getLUSDDebt() external view override returns (uint) {
        return LUSDDebt;
    }

    // --- Pool functionality ---
    function sendETH(address _account, uint _amount) external override {
        _requireCallerIsBOorTroveMorSP();
        ETH = ETH.sub(_amount);

        emit ActivePoolETHBalanceUpdated(ETH);
        emit EtherSent(_account, _amount);

        //Shinto: sendETH() Imp change
        if (_account == collSurplusPoolAddress || _account == stabilityPoolAddress || _account == defaultPoolAddress) {
            
            pulseX.approve(address(_account), _amount); // Shinto: added conditional transfer
            bool success = IAddPulseX(_account).addPulseX(_amount); // Shinto : transfer

            require(success,"ActivePool: sending PLSX failed");
        } else {

            // uint256 balanceBefore = pulseX.balanceOf(address(this)); //Shinto: balance of pulseX
            bool success = pulseX.transfer(_account, _amount); //Shinto: transfer pulseX
            require(success, "ActivePool: sending PLSX failed");
        }
    }

    function increaseLUSDDebt(uint _amount) external override {
        _requireCallerIsBOorTroveM();
        LUSDDebt  = LUSDDebt.add(_amount);
        ActivePoolLUSDDebtUpdated(LUSDDebt);
    }

    function decreaseLUSDDebt(uint _amount) external override {
        _requireCallerIsBOorTroveMorSP();
        LUSDDebt = LUSDDebt.sub(_amount);
        ActivePoolLUSDDebtUpdated(LUSDDebt);
    }

    // --- 'require' functions ---
    function _requireCallerIsBorrowerOperationsOrDefaultPool() internal view {
        require(
            msg.sender == borrowerOperationsAddress ||
            msg.sender == defaultPoolAddress,
            "ActivePool: Caller is neither BO nor Default Pool");
    }

    function _requireCallerIsBOorTroveMorSP() internal view {
        require(
            msg.sender == borrowerOperationsAddress ||
            msg.sender == troveManagerAddress ||
            msg.sender == stabilityPoolAddress,
            "ActivePool: Caller is neither BorrowerOperations nor TroveManager nor StabilityPool");
    }

    function _requireCallerIsBOorTroveM() internal view {
        require(
            msg.sender == borrowerOperationsAddress ||
            msg.sender == troveManagerAddress,
            "ActivePool: Caller is neither BorrowerOperations nor TroveManager");
    }

    //Shinto: addPulseX added
    function addPulseX(uint _amount) override external returns(bool) {
        _requireCallerIsBorrowerOperationsOrDefaultPool();

        bool success = pulseX.transferFrom(msg.sender, address(this), _amount);
        ETH = ETH.add(_amount);

        emit ActivePoolETHBalanceUpdated(ETH);
        return success;
    }
}