wip: compiles

Author: xenide

foundry.toml

@@ -1,6 +1,7 @@
 [profile.default]
-solc = "0.8.23"
+solc = "0.8.28"
 #via_ir = true
+evm_version = "cancun"
 bytecode_hash = "ipfs"
 optimizer_runs = 1_000_000
 gas_limit = "18446744073709551615"

src/GenericFactory.sol

@@ -3,8 +3,8 @@ pragma solidity ^0.8.0;
 
 import { Math } from "@openzeppelin/utils/math/Math.sol";
 import { Address } from "@openzeppelin/utils/Address.sol";
+import { Ownable } from "@openzeppelin/access/Ownable.sol";
 import { SSTORE2 } from "solady/utils/SSTORE2.sol";
-import { Owned } from "solmate/auth/Owned.sol";
 
 import { Bytes32Lib } from "src/libraries/Bytes32.sol";
 
@@ -13,12 +13,12 @@ import { StableMintBurn } from "src/curve/stable/StableMintBurn.sol";
 
 uint256 constant MAX_SSTORE_SIZE = 0x6000 - 1;
 
-contract GenericFactory is IGenericFactory, Owned {
+contract GenericFactory is IGenericFactory, Ownable {
     using Bytes32Lib for address;
 
     StableMintBurn public immutable stableMintBurn;
 
-    constructor() Owned(msg.sender) {
+    constructor() Ownable (msg.sender) {
         stableMintBurn = new StableMintBurn{ salt: bytes32(0) }();
     }
 
@@ -185,6 +185,6 @@ contract GenericFactory is IGenericFactory, Owned {
         onlyOwner
         returns (bytes memory)
     {
-        return Address.functionCallWithValue(aTarget, aCalldata, aValue, "FACTORY: RAW_CALL_REVERTED");
+        return Address.functionCallWithValue(aTarget, aCalldata, aValue);
     }
 }

src/ReservoirDeployer.sol

@@ -150,6 +150,6 @@ contract ReservoirDeployer {
         onlyOwner
         returns (bytes memory)
     {
-        return Address.functionCallWithValue(aTarget, aCalldata, aValue, "DEPLOYER: RAW_CALL_REVERTED");
+        return Address.functionCallWithValue(aTarget, aCalldata, aValue);
     }
 }

src/ReservoirPair.sol

@@ -2,6 +2,7 @@
 pragma solidity ^0.8.0;
 
 import { SafeCast } from "@openzeppelin/utils/math/SafeCast.sol";
+import { ReentrancyGuardTransient } from "@openzeppelin/utils/ReentrancyGuardTransient.sol";
 import { FixedPointMathLib } from "solady/utils/FixedPointMathLib.sol";
 import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
 
@@ -19,7 +20,7 @@ import { Observation } from "src/structs/Observation.sol";
 import { Slot0 } from "src/structs/Slot0.sol";
 import { ReservoirERC20 } from "src/ReservoirERC20.sol";
 
-abstract contract ReservoirPair is IAssetManagedPair, ReservoirERC20 {
+abstract contract ReservoirPair is IAssetManagedPair, ReservoirERC20, ReentrancyGuardTransient {
     using FactoryStoreLib for IGenericFactory;
     using Bytes32Lib for bytes32;
     using SafeCast for uint256;
@@ -96,48 +97,23 @@ abstract contract ReservoirPair is IAssetManagedPair, ReservoirERC20 {
 
     //////////////////////////////////////////////////////////////////////////*/
 
-    Slot0 internal _slot0 = Slot0({ reserve0: 0, reserve1: 0, packedTimestamp: 0, index: Buffer.SIZE - 1 });
+    Slot0 internal _slot0 = Slot0({ reserve0: 0, reserve1: 0, timestamp: 0, index: Buffer.SIZE - 1 });
 
-    function _currentTime() internal view returns (uint32) {
-        return uint32(block.timestamp & 0x7FFFFFFF);
-    }
-
-    function _splitSlot0Timestamp(uint32 aPackedTimestamp) internal pure returns (uint32 rTimestamp, bool rLocked) {
-        rLocked = aPackedTimestamp >> 31 == 1;
-        rTimestamp = aPackedTimestamp & 0x7FFFFFFF;
-    }
-
-    /// @notice Writes the packed timestamp & re-entrancy guard into slot0.
-    /// @dev The timestamp argument must not exceed 2**31.
-    function _writeSlot0Timestamp(Slot0 storage sSlot0, uint32 aTimestamp, bool aLocked) internal {
-        uint32 lLocked = aLocked ? uint32(1 << 31) : uint32(0);
-        sSlot0.packedTimestamp = aTimestamp | lLocked;
-    }
-
-    function _lockAndLoad()
+    function _load()
         internal
         returns (Slot0 storage, uint104 rReserve0, uint104 rReserve1, uint32 rBlockTimestampLast, uint16 rIndex)
     {
         Slot0 storage sSlot0 = _slot0;
 
         // Load slot0 values.
-        bool lLock;
         rReserve0 = sSlot0.reserve0;
         rReserve1 = sSlot0.reserve1;
-        (rBlockTimestampLast, lLock) = _splitSlot0Timestamp(sSlot0.packedTimestamp);
+        rBlockTimestampLast = sSlot0.timestamp;
         rIndex = sSlot0.index;
 
-        // Acquire reentrancy lock.
-        require(!lLock, "REENTRANCY");
-        _writeSlot0Timestamp(sSlot0, rBlockTimestampLast, true);
-
         return (sSlot0, rReserve0, rReserve1, rBlockTimestampLast, rIndex);
     }
 
-    function _unlock(Slot0 storage sSlot0, uint32 aBlockTimestampLast) internal {
-        _writeSlot0Timestamp(sSlot0, aBlockTimestampLast, false);
-    }
-
     /// @notice Updates reserves with new balances.
     /// @notice On the first call per block, accumulate price oracle using previous instant prices and write the new instant prices.
     /// @dev The price is not updated on subsequent swaps as manipulating
@@ -153,7 +129,7 @@ abstract contract ReservoirPair is IAssetManagedPair, ReservoirERC20 {
         require(aBalance0 <= type(uint104).max && aBalance1 <= type(uint104).max, "RP: OVERFLOW");
         require(aReserve0 <= type(uint104).max && aReserve1 <= type(uint104).max, "RP: OVERFLOW");
 
-        uint32 lBlockTimestamp = _currentTime();
+        uint32 lBlockTimestamp = uint32(block.timestamp); // invalid after year 2106
         uint32 lTimeElapsed;
         unchecked {
             // underflow is desired
@@ -199,7 +175,7 @@ abstract contract ReservoirPair is IAssetManagedPair, ReservoirERC20 {
         // update reserves to match latest balances
         sSlot0.reserve0 = uint104(aBalance0);
         sSlot0.reserve1 = uint104(aBalance1);
-        _writeSlot0Timestamp(sSlot0, lBlockTimestamp, false);
+        sSlot0.timestamp = lBlockTimestamp;
 
         emit Sync(uint104(aBalance0), uint104(aBalance1));
     }
@@ -213,25 +189,26 @@ abstract contract ReservoirPair is IAssetManagedPair, ReservoirERC20 {
 
         rReserve0 = lSlot0.reserve0;
         rReserve1 = lSlot0.reserve1;
-        (rBlockTimestampLast,) = _splitSlot0Timestamp(lSlot0.packedTimestamp);
+        rBlockTimestampLast = lSlot0.timestamp;
         rIndex = lSlot0.index;
     }
 
     /// @notice Force reserves to match balances.
-    function sync() external {
-        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _lockAndLoad();
+    function sync() external nonReentrant {
+        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _load();
         (lReserve0, lReserve1) = _syncManaged(lReserve0, lReserve1);
 
         _updateAndUnlock(sSlot0, _totalToken0(), _totalToken1(), lReserve0, lReserve1, lBlockTimestampLast);
     }
 
     /// @notice Force balances to match reserves.
-    function skim(address aTo) external {
-        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _lockAndLoad();
+    function skim(address aTo) external nonReentrant {
+        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _load();
 
         _checkedTransfer(token0(), aTo, _totalToken0() - lReserve0, lReserve0, lReserve1);
         _checkedTransfer(token1(), aTo, _totalToken1() - lReserve1, lReserve0, lReserve1);
-        _unlock(sSlot0, lBlockTimestampLast);
+
+        // might need to do an update here
     }
 
     /*//////////////////////////////////////////////////////////////////////////

src/asset-management/AaveManager.sol

@@ -122,7 +122,7 @@ contract AaveManager is IAssetManager, Owned(msg.sender), ReentrancyGuard {
         onlyOwner
         returns (bytes memory)
     {
-        return Address.functionCallWithValue(aTarget, aCalldata, aValue, "AM: RAW_CALL_REVERTED");
+        return Address.functionCallWithValue(aTarget, aCalldata, aValue);
     }
     /*//////////////////////////////////////////////////////////////////////////
                                 HELPER FUNCTIONS

src/curve/constant-product/ConstantProductPair.sol

@@ -91,8 +91,8 @@ contract ConstantProductPair is ReservoirPair {
         }
     }
 
-    function mint(address aTo) external override returns (uint256 rLiquidity) {
-        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _lockAndLoad();
+    function mint(address aTo) external override nonReentrant returns (uint256 rLiquidity) {
+        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _load();
         (lReserve0, lReserve1) = _syncManaged(uint104(lReserve0), uint104(lReserve1)); // check asset-manager pnl
 
         uint256 lBalance0 = _totalToken0();
@@ -122,9 +122,9 @@ contract ConstantProductPair is ReservoirPair {
         _managerCallback();
     }
 
-    function burn(address aTo) external override returns (uint256 rAmount0, uint256 rAmount1) {
+    function burn(address aTo) external override nonReentrant returns (uint256 rAmount0, uint256 rAmount1) {
         // NB: Must sync management PNL before we load reserves.
-        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _lockAndLoad();
+        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _load();
         (lReserve0, lReserve1) = _syncManaged(uint104(lReserve0), uint104(lReserve1)); // check asset-manager pnl
 
         uint256 liquidity = balanceOf[address(this)];
@@ -152,9 +152,10 @@ contract ConstantProductPair is ReservoirPair {
     function swap(int256 aAmount, bool aExactIn, address aTo, bytes calldata aData)
         external
         override
+        nonReentrant
         returns (uint256 rAmountOut)
     {
-        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _lockAndLoad();
+        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _load();
         require(aAmount != 0, "CP: AMOUNT_ZERO");
         uint256 lAmountIn;
         IERC20 lTokenOut;

src/curve/stable/StableMintBurn.sol

@@ -78,7 +78,7 @@ contract StableMintBurn is StablePair {
 
     function mint(address aTo) external override returns (uint256 rLiquidity) {
         // NB: Must sync management PNL before we load reserves.
-        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _lockAndLoad();
+        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _load();
         (lReserve0, lReserve1) = _syncManaged(lReserve0, lReserve1);
 
         uint256 lBalance0 = _totalToken0();
@@ -123,7 +123,7 @@ contract StableMintBurn is StablePair {
 
     function burn(address aTo) external override returns (uint256 rAmount0, uint256 rAmount1) {
         // NB: Must sync management PNL before we load reserves.
-        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _lockAndLoad();
+        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _load();
         (lReserve0, lReserve1) = _syncManaged(lReserve0, lReserve1);
 
         uint256 liquidity = balanceOf[address(this)];

src/curve/stable/StablePair.sol

@@ -128,9 +128,10 @@ contract StablePair is ReservoirPair {
         external
         virtual
         override
+        nonReentrant
         returns (uint256 rAmountOut)
     {
-        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _lockAndLoad();
+        (Slot0 storage sSlot0, uint256 lReserve0, uint256 lReserve1, uint32 lBlockTimestampLast,) = _load();
         require(aAmount != 0, "SP: AMOUNT_ZERO");
         uint256 lAmountIn;
         IERC20 lTokenOut;

src/structs/Slot0.sol

@@ -4,6 +4,6 @@ pragma solidity ^0.8.0;
 struct Slot0 {
     uint104 reserve0;
     uint104 reserve1;
-    uint32 packedTimestamp;
+    uint32 timestamp;
     uint16 index;
 }