test: add simple transient storage unit fuzz test

Author: lumoswiz

src/SubscriptionModule.sol

@@ -28,7 +28,7 @@ contract SubscriptionModule {
 
     using CirclesLib for TypeDefinitions.Stream[];
 
-    using LibTransient for *;
+    using LibTransient for LibTransient.TUint256;
 
     /*//////////////////////////////////////////////////////////////
                             STATE VARIABLES

test/Base.t.sol

@@ -3,6 +3,7 @@ pragma solidity >=0.8.28 <0.9.0;
 
 import { ModuleHarness } from "./harness/ModuleHarness.sol";
 
+import { TransientPattern } from "./mocks/TransientPattern.sol";
 import { Assertions } from "./utils/Assertions.sol";
 import { Defaults } from "./utils/Defaults.sol";
 import { Fuzzers } from "./utils/Fuzzers.sol";
@@ -23,6 +24,7 @@ abstract contract Base_Test is Assertions, Fuzzers, Modifiers {
     Defaults internal defaults;
 
     ModuleHarness internal module;
+    TransientPattern internal transientPattern;
 
     /*//////////////////////////////////////////////////////////////
                             SET-UP FUNCTION
@@ -40,6 +42,9 @@ abstract contract Base_Test is Assertions, Fuzzers, Modifiers {
         module = new ModuleHarness();
         vm.label(address(module), "ModuleHarness");
 
+        transientPattern = new TransientPattern();
+        vm.label(address(transientPattern), "TransientPattern");
+
         defaults.setUsers(users);
         setVariables(defaults, users);
 

test/mocks/TransientPattern.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { LibTransient } from "@solady/src/utils/LibTransient.sol";
+
+contract TransientPattern {
+    using LibTransient for LibTransient.TUint256;
+
+    bytes32 public constant T_REDEEMABLE_AMOUNT = 0x70bfbb43a5ce660914e09d1b48fcc488982d5981137b973eac35b0592a414e90;
+
+    struct Data {
+        uint256 a;
+        uint256 l;
+        uint256 f;
+    }
+
+    Data internal data;
+
+    bytes32 public v;
+
+    function create(uint256 a, uint256 f) external {
+        require(f > 0);
+        data = Data({ a: a, l: block.timestamp - f, f: f });
+    }
+
+    function redeem(bool isDoSomething) external {
+        Data memory d = data;
+
+        // Calculate periods
+        uint256 p = (block.timestamp - d.l) / d.f;
+        require(p >= 1);
+
+        // Update data
+        d.l += p * d.f;
+        data = d;
+
+        // Set transient storage
+        LibTransient.tUint256(T_REDEEMABLE_AMOUNT).set(p * d.a);
+
+        if (isDoSomething) _doSomething();
+        else _doSomethingElse();
+
+        // Best practice
+        LibTransient.tUint256(T_REDEEMABLE_AMOUNT).clear();
+    }
+
+    function _doSomething() internal {
+        v = keccak256(abi.encode("SOMETHING", LibTransient.tUint256(T_REDEEMABLE_AMOUNT).get()));
+    }
+
+    function _doSomethingElse() internal {
+        v = keccak256(abi.encode("SOMETHING_ELSE", LibTransient.tUint256(T_REDEEMABLE_AMOUNT).get()));
+    }
+
+    function getData() external view returns (Data memory) {
+        return data;
+    }
+}

test/unit/fuzz/transient-storage/TransientPattern.t.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.28 <0.9.0;
+
+import { Base_Test } from "test/Base.t.sol";
+
+import { TransientPattern } from "test/mocks/TransientPattern.sol";
+
+contract TransientPattern_Unit_Fuzz_Test is Base_Test {
+    function testFuzz_TransientFlows(uint256 a, uint256 f, uint256 t, bool flag) external {
+        a = bound(a, 1e18, 100_000_000e18);
+        f = bound(f, 3600, 86_400);
+        t = bound(t, f + 1, 10 * f);
+
+        // Create
+        transientPattern.create(a, f);
+
+        // Cache last redeemed
+        uint256 l = vm.getBlockTimestamp() - f;
+
+        // Time warp
+        vm.warp(vm.getBlockTimestamp() + t);
+
+        // Assert
+        TransientPattern.Data memory ld = TransientPattern.Data(a, l, f);
+        assertEq(keccak256(abi.encode(transientPattern.getData())), keccak256(abi.encode(ld)));
+
+        // Cache expected transient amount
+        uint256 periods = (vm.getBlockTimestamp() - l) / f;
+        uint256 ta = periods * a;
+
+        emit log_named_uint("periods", periods);
+        emit log_named_uint("transient amount", ta);
+
+        // Redeem
+        transientPattern.redeem(flag);
+
+        // Assert
+        assertEq(transientPattern.v(), _expectedValue(flag, ta));
+
+        // Can we access the transient slot and get a non-zero value?
+        uint256 shouldBeZero = uint256(vm.load(address(transientPattern), transientPattern.T_REDEEMABLE_AMOUNT()));
+        assertEq(shouldBeZero, 0);
+    }
+
+    function _expectedValue(bool isDoSomething, uint256 ta) internal returns (bytes32) {
+        return (isDoSomething) ? _getHash("SOMETHING", ta) : _getHash("SOMETHING_ELSE", ta);
+    }
+
+    function _getHash(string memory s, uint256 ta) internal returns (bytes32) {
+        return keccak256(abi.encode(s, ta));
+    }
+}