TempleDAO

1pragma solidity ^0.8.4;
2// SPDX-License-Identifier: AGPL-3.0-or-later
3
4import "@openzeppelin/contracts/access/Ownable.sol";
5import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
6
7import "./Vault.sol";
8import "../ABDKMathQuad.sol";
9import "../OGTemple.sol";
10import "../TempleERC20Token.sol";
11import "../TempleStaking.sol";
12import "../devotion/Faith.sol";
13
14/**
15    @notice A proxy contract for interacting with Temple Vaults. 
16 */
17contract VaultProxy is Ownable {
18    using ABDKMathQuad for bytes16;
19    /** @notice Tokens / Contracted required for the proxy contract  */
20    OGTemple public immutable ogTemple;
21    TempleERC20Token public immutable temple;
22    TempleStaking public immutable templeStaking;
23    Faith public immutable faith;
24    bool public faithClaimEnabled;
25
26    constructor(
27        OGTemple _ogTemple,
28        TempleERC20Token _temple,
29        TempleStaking _templeStaking,
30        Faith _faith
31    ) {
32        ogTemple = _ogTemple;
33        temple = _temple;
34        templeStaking = _templeStaking;
35        faith = _faith;
36        faithClaimEnabled = true;
37    }
38
39    bytes16 private constant MAX_MULT = 0x3fff4ccccccccccccccccccccccccccc; // 1.3
40    bytes16 private constant TA_MULT = 0x40004000000000000000000000000000; // 2.5
41
42    /**
43        @notice Given an amount of Faith and Temple, apply the boosting curve and strapiuce the amount of boosted Temple one can expect to receive.
44                Formula is BoostedTemple = TempleProvided * min(1.3, (1+faith/(2.5*TempleProvided)))
45     */
46    function getFaithMultiplier(uint256 _amountFaith, uint256 _amountTemple) pure public returns (uint256) {
47        // Tl = Ta * min(1.3, (1+faith/2.5*Ta))
48        bytes16 amountFaith = ABDKMathQuad.fromUInt(_amountFaith);
49        bytes16 amountTemple = ABDKMathQuad.fromUInt(_amountTemple);
50        bytes16 t = ABDKMathQuad.fromUInt(1).add(amountFaith.div(TA_MULT.mul(amountTemple)));
51        bytes16 mult = MAX_MULT < t ? MAX_MULT : t;
52
53        return ABDKMathQuad.toUInt(amountTemple.mul(mult));
54    }
55
56    /**
57        @notice Takes provided faith and Temple, applies the boost then immediate deposits into a vault
58     */
59    function depositTempleWithFaith(uint256 _amountTemple, uint112 _amountFaith, Vault vault) public {
60        require(faithClaimEnabled, "VaultProxy: Faith claim no longer enabled");
61        faith.redeem(msg.sender, _amountFaith);
62        uint256 boostedAmount = getFaithMultiplier(_amountFaith, _amountTemple);
63        SafeERC20.safeTransferFrom(temple, msg.sender, address(this), _amountTemple);
64        SafeERC20.safeIncreaseAllowance(temple, address(vault), boostedAmount);
65        vault.depositFor(msg.sender, boostedAmount);
66    }
67
68    /**
69        @notice Takes provided faith and OGT, unstakes the OGT into Temple, applies the boost and then immediately
70        deposits into a vault
71     */
72    function unstakeAndDepositTempleWithFaith(uint256 _amountOGT, uint112 _amountFaith, Vault vault) external {
73        require(faithClaimEnabled, "VaultProxy: Faith claim no longer enabled");
74        faith.redeem(msg.sender, _amountFaith);
75        uint256 unstakedTemple = unstakeOGT(_amountOGT);
76        uint256 boostedAmount = getFaithMultiplier(_amountFaith, unstakedTemple);
77        SafeERC20.safeIncreaseAllowance(temple, address(vault), boostedAmount);
78        vault.depositFor(msg.sender, boostedAmount);
79    }
80
81    /**
82        @notice Takes provided OGT, unstakes into Temple and immediately deposits into a vault
83     */
84    function unstakeAndDepositIntoVault(uint256 _amountOGT, Vault vault) external {
85        uint256 unstakedTemple = unstakeOGT(_amountOGT);
86        SafeERC20.safeIncreaseAllowance(temple, address(vault), unstakedTemple);
87        vault.depositFor(msg.sender, unstakedTemple);
88    }
89    
90    /**
91        @notice Private function which will take OGT, unstake it, ensure correct amount came back and then pass back 
92        to the calling function.
93     */
94    function unstakeOGT(uint256 _amountOGT) private returns (uint256) {
95        SafeERC20.safeIncreaseAllowance(ogTemple, address(templeStaking), _amountOGT);
96        SafeERC20.safeTransferFrom(ogTemple, msg.sender, address(this), _amountOGT);
97        
98        uint256 templeBeforeBalance = temple.balanceOf(address(this));
99        templeStaking.unstake(_amountOGT);
100        uint256 templeAfterBalance = temple.balanceOf(address(this));
101        require(templeAfterBalance > templeBeforeBalance, "Vault Proxy: no Temple received when unstaking");
102
103        return templeAfterBalance - templeBeforeBalance;
104    }
105
106    /**
107        @notice A proxy function for depositing into a vault; useful if we wish to limit number of approvals to one, rather than for each underlying 
108                vault instance. 
109     */
110    function depositTempleFor(uint256 _amount, Vault vault) public {
111        SafeERC20.safeIncreaseAllowance(temple, address(vault), _amount);
112        SafeERC20.safeTransferFrom(temple, msg.sender, address(this), _amount);
113        vault.depositFor(msg.sender, _amount);
114    }
115
116    /**
117    * Toggle whether faith is claimable
118    */
119    function toggleFaithClaimEnabled() external onlyOwner {
120        faithClaimEnabled = !faithClaimEnabled;
121    }
122
123    /**
124    * transfer out amount of token to provided address
125    */
126    function withdraw(address token, address to, uint256 amount) external onlyOwner {
127        require(to != address(0), "to address zero");
128
129        if (token == address(0)) {
130            (bool sent,) = payable(to).call{value: amount}("");
131            require(sent, "send failed");
132        } else {
133            SafeERC20.safeTransfer(IERC20(token), to, amount);
134        }
135    }
136}

JavaScript Tests