Comparar texto

Encontre a diferença entre dois arquivos de texto

Exibição

Layout

Editor liveOcultar espaços em brancoRecolher inalteradasSem quebra de linha

Nível de detalhe

Sintaxe

Processamento

Diffchecker Desktop A maneira mais segura de usar o Diffchecker. Obtenha o aplicativo Diffchecker Desktop: seus diffs nunca saem do seu computador!Obter Desktop

Acropolis vs Masonry

Criado há 5 anosO diff nunca expira

100 remoções

Linhas
Total
Removido

Caracteres
Total
Removido

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

266 linhas

107 adições

Linhas
Total
Adicionado

Caracteres
Total
Adicionado

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

266 linhas

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import "@openzeppelin/contracts/utils/math/SafeMath.sol";

import "./utils/ContractGuard.sol";

import "./interfaces/IBasisAsset.sol";

import "./interfaces/ITreasury.sol";

contract ShareWrapper {

using SafeMath for uint256;

using SafeERC20 for IERC20;

IERC20 public share;

uint256 private _totalSupply;

mapping(address => uint256) private _balances;

function totalSupply() public view returns (uint256) {

return _totalSupply;

}

function balanceOf(address account) public view returns (uint256) {

return _balances[account];

}

function stake(uint256 amount) public virtual {

_totalSupply = _totalSupply.add(amount);

_balances[msg.sender] = _balances[msg.sender].add(amount);

share.safeTransferFrom(msg.sender, address(this), amount);

}

function withdraw(uint256 amount) public virtual {

uint256 masonShare = _balances[msg.sender];

uint256 andrasShare = _balances[msg.sender];

require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");

require(andrasShare >= amount, "Acropolis: withdraw request greater than staked amount");

_totalSupply = _totalSupply.sub(amount);

_balances[msg.sender] = masonShare.sub(amount);

_balances[msg.sender] = andrasShare.sub(amount);

share.safeTransfer(msg.sender, amount);

}

______ __ _______

__________ .___ ___________.__

/_ __/___ ____ ___ / /_ / ____(_)___ ____ _____ ________

\______ \_____ ______ ____ __| _/ \_ _____/|__| ____ _____ ____ ____ ____

/ / / __ \/ __ `__ \/ __ \ / /_ / / __ \/ __ `/ __ \/ ___/ _ \

| | _/\__ \ / ___/_/ __ \ / __ | | __) | | / \ \__ \ / \ _/ ___\_/ __ \

/ / / /_/ / / / / / / /_/ / / __/ / / / / / /_/ / / / / /__/ __/

| | \ / __ \_ \___ \ \ ___/ / /_/ | | \ | || | \ / __ \_| | \\ \___\ ___/

/_/ \____/_/ /_/ /_/_.___/ /_/ /_/_/ /_/\__,_/_/ /_/\___/\___/

|______ /(____ //____ > \___ >\____ | \___ / |__||___| /(____ /|___| / \___ >\___ >

\/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/

http://tomb.finance

contract Masonry is ShareWrapper, ContractGuard {

contract Acropolis is ShareWrapper, ContractGuard {

using SafeERC20 for IERC20;

using Address for address;

using SafeMath for uint256;

/* ========== DATA STRUCTURES ========== */

struct Masonseat {

struct Ecclesiaseat {

uint256 lastSnapshotIndex;

uint256 rewardEarned;

uint256 epochTimerStart;

}

struct MasonrySnapshot {

struct AcropolisSnapshot {

uint256 time;

uint256 rewardReceived;

uint256 rewardPerShare;

}

/* ========== STATE VARIABLES ========== */

// governance

address public operator;

// flags

bool public initialized = false;

IERC20 public tomb;

IERC20 public based;

ITreasury public treasury;

mapping(address => Masonseat) public masons;

mapping(address => Ecclesiaseat) public demos;

MasonrySnapshot[] public masonryHistory;

AcropolisSnapshot[] public acropolisHistory;

uint256 public withdrawLockupEpochs;

uint256 public rewardLockupEpochs;

/* ========== EVENTS ========== */

event Initialized(address indexed executor, uint256 at);

event Staked(address indexed user, uint256 amount);

event Withdrawn(address indexed user, uint256 amount);

event RewardPaid(address indexed user, uint256 reward);

event RewardAdded(address indexed user, uint256 reward);

/* ========== Modifiers =============== */

modifier onlyOperator() {

require(operator == msg.sender, "Masonry: caller is not the operator");

require(operator == msg.sender, "Acropolis: caller is not the operator");

}

modifier masonExists {

modifier andrasExists {

require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");

require(balanceOf(msg.sender) > 0, "Acropolis: The andras does not exist");

}

modifier updateReward(address mason) {

modifier updateReward(address andras) {

if (mason != address(0)) {

if (andras != address(0)) {

Masonseat memory seat = masons[mason];

Ecclesiaseat memory seat = demos[andras];

seat.rewardEarned = earned(mason);

seat.rewardEarned = earned(andras);

Diferenças salvas

Texto original

Abrir arquivo

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";

import "./utils/ContractGuard.sol";
import "./interfaces/IBasisAsset.sol";
import "./interfaces/ITreasury.sol";

contract ShareWrapper {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

IERC20 public share;

uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

function stake(uint256 amount) public virtual {
        _totalSupply = _totalSupply.add(amount);
        _balances[msg.sender] = _balances[msg.sender].add(amount);
        share.safeTransferFrom(msg.sender, address(this), amount);
    }

function withdraw(uint256 amount) public virtual {
        uint256 masonShare = _balances[msg.sender];
        require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
        _totalSupply = _totalSupply.sub(amount);
        _balances[msg.sender] = masonShare.sub(amount);
        share.safeTransfer(msg.sender, amount);
    }
}

/*
  ______                __       _______
 /_  __/___  ____ ___  / /_     / ____(_)___  ____ _____  ________
  / / / __ \/ __ `__ \/ __ \   / /_  / / __ \/ __ `/ __ \/ ___/ _ \
 / / / /_/ / / / / / / /_/ /  / __/ / / / / / /_/ / / / / /__/  __/
/_/  \____/_/ /_/ /_/_.___/  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/

http://tomb.finance
*/
contract Masonry is ShareWrapper, ContractGuard {
    using SafeERC20 for IERC20;
    using Address for address;
    using SafeMath for uint256;

/* ========== DATA STRUCTURES ========== */

struct Masonseat {
        uint256 lastSnapshotIndex;
        uint256 rewardEarned;
        uint256 epochTimerStart;
    }

struct MasonrySnapshot {
        uint256 time;
        uint256 rewardReceived;
        uint256 rewardPerShare;
    }

/* ========== STATE VARIABLES ========== */

// governance
    address public operator;

// flags
    bool public initialized = false;

IERC20 public tomb;
    ITreasury public treasury;

mapping(address => Masonseat) public masons;
    MasonrySnapshot[] public masonryHistory;

uint256 public withdrawLockupEpochs;
    uint256 public rewardLockupEpochs;

/* ========== EVENTS ========== */

event Initialized(address indexed executor, uint256 at);
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
    event RewardAdded(address indexed user, uint256 reward);

/* ========== Modifiers =============== */

modifier onlyOperator() {
        require(operator == msg.sender, "Masonry: caller is not the operator");
        _;
    }

modifier masonExists {
        require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
        _;
    }

modifier updateReward(address mason) {
        if (mason != address(0)) {
            Masonseat memory seat = masons[mason];
            seat.rewardEarned = earned(mason);
            seat.lastSnapshotIndex = latestSnapshotIndex();
            masons[mason] = seat;
        }
        _;
    }

modifier notInitialized {
        require(!initialized, "Masonry: already initialized");
        _;
    }

/* ========== GOVERNANCE ========== */

function initialize(
        IERC20 _tomb,
        IERC20 _share,
        ITreasury _treasury
    ) public notInitialized {
        tomb = _tomb;
        share = _share;
        treasury = _treasury;

MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
        masonryHistory.push(genesisSnapshot);

withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw
        rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward

initialized = true;
        operator = msg.sender;
        emit Initialized(msg.sender, block.number);
    }

function setOperator(address _operator) external onlyOperator {
        operator = _operator;
    }

function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
        require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
        withdrawLockupEpochs = _withdrawLockupEpochs;
        rewardLockupEpochs = _rewardLockupEpochs;
    }

/* ========== VIEW FUNCTIONS ========== */

// =========== Snapshot getters

function latestSnapshotIndex() public view returns (uint256) {
        return masonryHistory.length.sub(1);
    }

function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
        return masonryHistory[latestSnapshotIndex()];
    }

function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
        return masons[mason].lastSnapshotIndex;
    }

function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
        return masonryHistory[getLastSnapshotIndexOf(mason)];
    }

function canWithdraw(address mason) external view returns (bool) {
        return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
    }

function canClaimReward(address mason) external view returns (bool) {
        return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
    }

function epoch() external view returns (uint256) {
        return treasury.epoch();
    }

function nextEpochPoint() external view returns (uint256) {
        return treasury.nextEpochPoint();
    }

function getTombPrice() external view returns (uint256) {
        return treasury.getTombPrice();
    }

// =========== Mason getters

function rewardPerShare() public view returns (uint256) {
        return getLatestSnapshot().rewardPerShare;
    }

function earned(address mason) public view returns (uint256) {
        uint256 latestRPS = getLatestSnapshot().rewardPerShare;
        uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;

return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
    }

/* ========== MUTATIVE FUNCTIONS ========== */

function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
        require(amount > 0, "Masonry: Cannot stake 0");
        super.stake(amount);
        masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
        emit Staked(msg.sender, amount);
    }

function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
        require(amount > 0, "Masonry: Cannot withdraw 0");
        require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
        claimReward();
        super.withdraw(amount);
        emit Withdrawn(msg.sender, amount);
    }

function exit() external {
        withdraw(balanceOf(msg.sender));
    }

function claimReward() public updateReward(msg.sender) {
        uint256 reward = masons[msg.sender].rewardEarned;
        if (reward > 0) {
            require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
            masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
            masons[msg.sender].rewardEarned = 0;
            tomb.safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
        require(amount > 0, "Masonry: Cannot allocate 0");
        require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");

// Create & add new snapshot
        uint256 prevRPS = getLatestSnapshot().rewardPerShare;
        uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));

MasonrySnapshot memory newSnapshot = MasonrySnapshot({
            time: block.number,
            rewardReceived: amount,
            rewardPerShare: nextRPS
        });
        masonryHistory.push(newSnapshot);

tomb.safeTransferFrom(msg.sender, address(this), amount);
        emit RewardAdded(msg.sender, amount);
    }

function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
        // do not allow to drain core tokens
        require(address(_token) != address(tomb), "tomb");
        require(address(_token) != address(share), "share");
        _token.safeTransfer(_to, _amount);
    }
}

Texto alterado

Abrir arquivo

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

import "./utils/ContractGuard.sol";
import "./interfaces/IBasisAsset.sol";
import "./interfaces/ITreasury.sol";

contract ShareWrapper {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

IERC20 public share;

uint256 private _totalSupply;
    mapping(address => uint256) private _balances;

function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

function withdraw(uint256 amount) public virtual {
        uint256 andrasShare = _balances[msg.sender];
        require(andrasShare >= amount, "Acropolis: withdraw request greater than staked amount");
        _totalSupply = _totalSupply.sub(amount);
        _balances[msg.sender] = andrasShare.sub(amount);
        share.safeTransfer(msg.sender, amount);
    }
}

/*
__________                             .___   ___________.__
\______   \_____     ______  ____    __| _/   \_   _____/|__|  ____  _____     ____    ____   ____
 |    |  _/\__  \   /  ___/_/ __ \  / __ |     |    __)  |  | /    \ \__  \   /    \ _/ ___\_/ __ \
 |    |   \ / __ \_ \___ \ \  ___/ / /_/ |     |     \   |  ||   |  \ / __ \_|   |  \\  \___\  ___/
 |______  /(____  //____  > \___  >\____ |     \___  /   |__||___|  /(____  /|___|  / \___  >\___  >
        \/      \/      \/      \/      \/         \/             \/      \/      \/      \/     \/
*/
contract Acropolis is ShareWrapper, ContractGuard {
    using SafeERC20 for IERC20;
    using Address for address;
    using SafeMath for uint256;

/* ========== DATA STRUCTURES ========== */

struct Ecclesiaseat {
        uint256 lastSnapshotIndex;
        uint256 rewardEarned;
        uint256 epochTimerStart;
    }

struct AcropolisSnapshot {
        uint256 time;
        uint256 rewardReceived;
        uint256 rewardPerShare;
    }

/* ========== STATE VARIABLES ========== */

// governance
    address public operator;

// flags
    bool public initialized = false;

IERC20 public based;
    ITreasury public treasury;

mapping(address => Ecclesiaseat) public demos;
    AcropolisSnapshot[] public acropolisHistory;

uint256 public withdrawLockupEpochs;
    uint256 public rewardLockupEpochs;

/* ========== EVENTS ========== */

/* ========== Modifiers =============== */

modifier onlyOperator() {
        require(operator == msg.sender, "Acropolis: caller is not the operator");
        _;
    }

modifier andrasExists {
        require(balanceOf(msg.sender) > 0, "Acropolis: The andras does not exist");
        _;
    }

modifier updateReward(address andras) {
        if (andras != address(0)) {
            Ecclesiaseat memory seat = demos[andras];
            seat.rewardEarned = earned(andras);
            seat.lastSnapshotIndex = latestSnapshotIndex();
            demos[andras] = seat;
        }
        _;
    }

modifier notInitialized {
        require(!initialized, "Acropolis: already initialized");
        _;
    }

/* ========== GOVERNANCE ========== */

function initialize(
        IERC20 _based,
        IERC20 _share,
        ITreasury _treasury
    ) public notInitialized {
        based = _based;
        share = _share;
        treasury = _treasury;

AcropolisSnapshot memory genesisSnapshot = AcropolisSnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
        acropolisHistory.push(genesisSnapshot);

withdrawLockupEpochs = 4; // Lock for 6 epochs (36h) before release withdraw
        rewardLockupEpochs = 2; // Lock for 3 epochs (18h) before release claimReward    !!! THIS IS ALTERED TO SMALLER PERIODS

initialized = true;
        operator = msg.sender;
        emit Initialized(msg.sender, block.number);
    }

function setOperator(address _operator) external onlyOperator {
        operator = _operator;
    }

/* ========== VIEW FUNCTIONS ========== */

// =========== Snapshot getters =========== //

function latestSnapshotIndex() public view returns (uint256) {
        return acropolisHistory.length.sub(1);
    }

function getLatestSnapshot() internal view returns (AcropolisSnapshot memory) {
        return acropolisHistory[latestSnapshotIndex()];
    }

function getLastSnapshotIndexOf(address andras) public view returns (uint256) {
        return demos[andras].lastSnapshotIndex;
    }

function getLastSnapshotOf(address andras) internal view returns (AcropolisSnapshot memory) {
        return acropolisHistory[getLastSnapshotIndexOf(andras)];
    }

function canWithdraw(address andras) external view returns (bool) {
        return demos[andras].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
    }

function canClaimReward(address andras) external view returns (bool) {
        return demos[andras].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
    }

function epoch() external view returns (uint256) {
        return treasury.epoch();
    }

function nextEpochPoint() external view returns (uint256) {
        return treasury.nextEpochPoint();
    }

function getBasedPrice() external view returns (uint256) {
        return treasury.getBasedPrice();
    }

// =========== Andras getters =========== //

function rewardPerShare() public view returns (uint256) {
        return getLatestSnapshot().rewardPerShare;
    }

function earned(address andras) public view returns (uint256) {
        uint256 latestRPS = getLatestSnapshot().rewardPerShare;
        uint256 storedRPS = getLastSnapshotOf(andras).rewardPerShare;

return balanceOf(andras).mul(latestRPS.sub(storedRPS)).div(1e18).add(demos[andras].rewardEarned);
    }

/* ========== MUTATIVE FUNCTIONS ========== */

function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
        require(amount > 0, "Acropolis: Cannot stake 0");
        super.stake(amount);
        demos[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
        emit Staked(msg.sender, amount);
    }

function withdraw(uint256 amount) public override onlyOneBlock andrasExists updateReward(msg.sender) {
        require(amount > 0, "Acropolis: Cannot withdraw 0");
        require(demos[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Acropolis: still in withdraw lockup");
        claimReward();
        super.withdraw(amount);
        emit Withdrawn(msg.sender, amount);
    }

function exit() external {
        withdraw(balanceOf(msg.sender));
    }

function claimReward() public updateReward(msg.sender) {
        uint256 reward = demos[msg.sender].rewardEarned;
        if (reward > 0) {
            require(demos[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Acropolis: still in reward lockup");
            demos[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
            demos[msg.sender].rewardEarned = 0;
            based.safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
        require(amount > 0, "Acropolis: Cannot allocate 0");
        require(totalSupply() > 0, "Acropolis: Cannot allocate when totalSupply is 0");

// Create & add new snapshot
        uint256 prevRPS = getLatestSnapshot().rewardPerShare;
        uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));

AcropolisSnapshot memory newSnapshot = AcropolisSnapshot({
            time: block.number,
            rewardReceived: amount,
            rewardPerShare: nextRPS
        });
        acropolisHistory.push(newSnapshot);

based.safeTransferFrom(msg.sender, address(this), amount);
        emit RewardAdded(msg.sender, amount);
    }

function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
        // do not allow to drain core tokens
        require(address(_token) != address(based), "based");
        require(address(_token) != address(share), "share");
        _token.safeTransfer(_to, _amount);
    }
}