temple gold contracts

.github/workflows/protocol-tests.yaml

@@ -50,6 +50,7 @@ jobs:
         working-directory: protocol
         env:
           TESTS_MAINNET_RPC_URL: ${{ secrets.TESTS_MAINNET_RPC_URL }}
+          ARBITRUM_ONE_RPC_URL: ${{ secrets.TESTS_ARBITRUM_ONE_RPC_URL }}
 
   foundryTests:
     name: Foundry Tests
@@ -106,6 +107,7 @@ jobs:
         env:
           FOUNDRY_PROFILE: ci
           MAINNET_RPC_URL: ${{ secrets.TESTS_MAINNET_RPC_URL }}
+          ARBITRUM_ONE_RPC_URL: ${{ secrets.TESTS_ARBITRUM_ONE_RPC_URL }}
 
   slither:
     name: Slither

protocol/.gitignore

@@ -27,4 +27,7 @@ lcov.info
 report
 
 # autogenerated fork args
-scripts/deploys/localhost/deploymentArgs
+scripts/deploys/localhost/deploymentArgs
+
+# templegold scripts
+test/forge/templegold/scripts/

protocol/contracts/amo/AuraStaking.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Temple (amo/AuraStaking.sol)
 

protocol/contracts/amo/Ramos.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Temple (amo/Ramos.sol)
 

protocol/contracts/common/CommonEventsAndErrors.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Temple (common/CommonEventsAndErrors.sol)
 
@@ -12,5 +12,4 @@ library CommonEventsAndErrors {
     error ExpectedNonZero();
     error Unimplemented();
     event TokenRecovered(address indexed to, address indexed token, uint256 amount);
-    error AccountBlacklisted(address account);
 }

protocol/contracts/common/SafeCast.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Temple (common/SafeCast.sol)
 

protocol/contracts/common/TempleMath.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.8.20;
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Temple (common/TempleMath.sol)
+
+import { mulDiv } from "@prb/math/src/Common.sol";
+
+library TempleMath {
+    /// @notice mulDiv with an option to round the result up or down to the nearest wei
+    function mulDivRound(uint256 x, uint256 y, uint256 denominator, bool roundUp) internal pure returns (uint256 result) {
+        result = mulDiv(x, y, denominator);
+        // See OZ Math.sol for the equivalent mulDiv() with rounding.
+        if (roundUp && mulmod(x, y, denominator) > 0) {
+            result += 1;
+        }
+    }
+}

protocol/contracts/common/access/ElevatedAccess.sol

@@ -0,0 +1,86 @@
+pragma solidity ^0.8.20;
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Temple (common/access/ElevatedAccess.sol)
+
+import { CommonEventsAndErrors } from "contracts/common/CommonEventsAndErrors.sol";
+import { IElevatedAccess } from "contracts/interfaces/common/access/IElevatedAccess.sol";
+
+/**
+ * @notice Inherit to add Owner roles for DAO elevated access.
+ */ 
+abstract contract ElevatedAccess is IElevatedAccess {
+    /**
+     * @notice The address of the current owner.
+     */ 
+    address public override owner;
+
+    /**
+     * @notice Explicit approval for an address to execute a function.
+     * allowedCaller => function selector => true/false
+     */
+    mapping(address => mapping(bytes4 => bool)) public override explicitFunctionAccess;
+
+    /// @dev Track proposed owner
+    address private _proposedNewOwner;
+
+    function _init(address initialOwner) internal {
+        if (owner != address(0)) revert CommonEventsAndErrors.InvalidAccess();
+        if (initialOwner == address(0)) revert CommonEventsAndErrors.InvalidAddress();
+        owner = initialOwner;
+    }
+
+    /**
+     * @notice Proposes a new Owner.
+     * Can only be called by the current owner
+     */
+    function proposeNewOwner(address account) external override onlyElevatedAccess {
+        if (account == address(0)) revert CommonEventsAndErrors.InvalidAddress();
+        emit NewOwnerProposed(owner, _proposedNewOwner, account);
+        _proposedNewOwner = account;
+    }
+
+    /**
+     * @notice Caller accepts the role as new Owner.
+     * Can only be called by the proposed owner
+     */
+    function acceptOwner() external override {
+        if (msg.sender != _proposedNewOwner) revert CommonEventsAndErrors.InvalidAccess();
+
+        emit NewOwnerAccepted(owner, msg.sender);
+        owner = msg.sender;
+        delete _proposedNewOwner;
+    }
+
+    /**
+     * @notice Grant `allowedCaller` the rights to call the function selectors in the access list.
+     * @dev fnSelector == bytes4(keccak256("fn(argType1,argType2,...)"))
+     */
+    function setExplicitAccess(address allowedCaller, ExplicitAccess[] calldata access) external override onlyElevatedAccess {
+        if (allowedCaller == address(0)) revert CommonEventsAndErrors.InvalidAddress();
+        uint256 _length = access.length;
+        ExplicitAccess memory _access;
+        for (uint256 i; i < _length; ++i) {
+            _access = access[i];
+            emit ExplicitAccessSet(allowedCaller, _access.fnSelector, _access.allowed);
+            explicitFunctionAccess[allowedCaller][_access.fnSelector] = _access.allowed;
+        }
+    }
+
+    function isElevatedAccess(address caller, bytes4 fnSelector) internal view returns (bool) {
+        return (
+            caller == owner || 
+            explicitFunctionAccess[caller][fnSelector]
+        );
+    }
+
+    /**
+     * @notice The owner is allowed to call, or if explicit access has been given to the caller.
+     * @dev Important: Only for use when called from an *external* contract. 
+     * If a function with this modifier is called internally then the `msg.sig` 
+     * will still refer to the top level externally called function.
+     */
+    modifier onlyElevatedAccess() {
+        if (!isElevatedAccess(msg.sender, msg.sig)) revert CommonEventsAndErrors.InvalidAccess();
+        _;
+    }
+}

protocol/contracts/core/MultiOtcOffer.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Temple (core/MultiOtcOffer.sol)
 

protocol/contracts/core/OtcOffer.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // Temple (core/OtcOffer.sol)
 

protocol/contracts/fakes/FakeERC20.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

protocol/contracts/fakes/FakeERC20CustomDecimals.sol

@@ -1,4 +1,4 @@
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

protocol/contracts/fakes/templegold/SpiceAuctionMock.sol

@@ -0,0 +1,125 @@
+pragma solidity ^0.8.18;
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Temple (templegold/SpiceAuctionMock.sol)
+
+
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { CommonEventsAndErrors } from "contracts/common/CommonEventsAndErrors.sol";
+import { ITempleGold } from "contracts/interfaces/templegold/ITempleGold.sol";
+import { SendParam } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oft/interfaces/IOFT.sol";
+import { MessagingFee } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oft/OFTCore.sol";
+import { OptionsBuilder } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/libs/OptionsBuilder.sol";
+
+/** 
+ * @title SpiceAuction
+ * @notice Temple Gold is deposited into this contract to bid on a share of distributed Spice token, 
+ * or vice versa, for an epoch. Temple Gold can be the bid or auction token at any auction epoch.
+ * Reward tokens acquired in past epochs can always be claimed. Once bid, users cannot
+ * claim their bid token and can only claim their share of reward token for epoch after epoch finishes.
+ * Bid and auction tokens could change per auction. These are set in `AuctionConfig`. 
+ * Config is set before the next auction starts using `setAuctionConfig` by DAO execution.
+ */
+contract SpiceAuctionMock {
+    using SafeERC20 for IERC20;
+    using OptionsBuilder for bytes;
+
+    /// @notice Temple GOLD
+    address public immutable templeGold;
+
+    /// @notice Auctions run for minimum 1 week
+    uint32 public constant MINIMUM_AUCTION_PERIOD = 1 weeks;
+    /// @notice Maximum wait period between last and next auctions
+    uint32 public constant MAXIMUM_AUCTION_WAIT_PERIOD = 90 days;
+    /// @notice Maximum auction duration
+    uint32 public constant MAXIMUM_AUCTION_DURATION = 30 days;
+    uint32 private immutable _arbitrumOneLzEid;
+    uint32 private immutable _mintChainId;
+    uint32 public lzReceiveExecutorGas;
+
+    /// @notice If true, let first claim for an auction notify total TGLD redeemed
+    bool public claimShouldNotifyTotalRedeemed;
+
+    /// @notice Name of this Spice Bazaar auction
+    string public name;
+
+    /// @notice Last time auction was started. For zero auctions, it is the contract deploy timestamp
+    uint256 private immutable _deployTimestamp;
+
+    event RedeemedTempleGoldBurned(uint256 amount);
+    error ExpectedNonZero();
+    error WithdrawFailed(uint256 amount);
+
+    constructor(
+        address _templeGold,
+        uint32 _arbEid,
+        uint32 mintChainId_,
+        string memory _name
+    ) {
+        templeGold = _templeGold;
+        _arbitrumOneLzEid = _arbEid;
+        _mintChainId = mintChainId_;
+        name = _name;
+        _deployTimestamp = block.timestamp;
+        lzReceiveExecutorGas = 85_412;
+    }
+
+    /// @notice withdraw ETH used for layer zero sends
+    function withdrawEth(address payable _to, uint256 _amount) external {
+        (bool success,) = _to.call{ value: _amount }("");
+        if (!success) { revert WithdrawFailed(_amount); }
+    }
+
+    /**
+     * @notice Burn redeemd TGLD and notify circulating supply
+     * @param amount Amount
+     * @param useContractEth If to use contract eth for layerzero send
+     */
+    function burnAndNotify(uint256 amount, bool useContractEth) external payable {
+        if (amount == 0) { revert ExpectedNonZero(); }
+
+        emit RedeemedTempleGoldBurned(amount);
+        _burnAndNotify(amount, useContractEth);
+    }
+
+    function _burnAndNotify(uint256 amount, bool useContractEth) private {
+        // burn directly and call TempleGold to update circulating supply
+        if (block.chainid == _mintChainId) {
+            ITempleGold(templeGold).burn(amount);
+            return;
+        }
+        bytes memory options = OptionsBuilder.newOptions().addExecutorLzReceiveOption(lzReceiveExecutorGas, 0);
+        SendParam memory sendParam = SendParam(
+            _arbitrumOneLzEid, //<ARB_EID>,
+            bytes32(uint256(uint160(address(0)))), // bytes32(address(0)) to burn
+            amount,
+            0,
+            options,
+            bytes(""), // compose message
+            ""
+        );
+        MessagingFee memory fee = ITempleGold(templeGold).quoteSend(sendParam, false);
+        if (useContractEth && address(this).balance < fee.nativeFee) {
+            revert CommonEventsAndErrors.InsufficientBalance(address(0), fee.nativeFee, address(this).balance);
+        } else if (!useContractEth && msg.value < fee.nativeFee) {
+            revert CommonEventsAndErrors.InsufficientBalance(address(0), fee.nativeFee, msg.value); 
+        }
+
+        if (useContractEth) {
+            ITempleGold(templeGold).send{ value: fee.nativeFee }(sendParam, fee, payable(address(this)));
+        } else {
+            ITempleGold(templeGold).send{ value: fee.nativeFee }(sendParam, fee, payable(msg.sender));
+            uint256 leftover;
+            unchecked {
+                leftover = msg.value - fee.nativeFee;
+            }
+            if (leftover > 0) { 
+                (bool success,) = payable(msg.sender).call{ value: leftover }("");
+                if (!success) { revert WithdrawFailed(leftover); }
+            }
+        }
+    }
+
+    // allow this contract to receive ether
+    receive() external payable {}
+}