@zoralabs/coins 2.1.2 → 2.3.0

package/test/ZoraHookRegistry.t.sol

@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.28;
+
+import "forge-std/Test.sol";
+
+import {IZoraHookRegistry} from "../src/interfaces/IZoraHookRegistry.sol";
+import {ZoraHookRegistry} from "../src/hook-registry/ZoraHookRegistry.sol";
+
+contract MockHook {
+    function contractVersion() public pure returns (string memory) {
+        return "0.0.0";
+    }
+}
+
+contract ZoraHookRegistryTest is Test {
+    uint256 internal forkId;
+    address internal owner;
+
+    ZoraHookRegistry internal zoraHookRegistry;
+    MockHook internal mockHook;
+
+    function setUp() public {
+        forkId = vm.createSelectFork("base", 34509280);
+        owner = makeAddr("owner");
+
+        address[] memory initialOwners = new address[](1);
+        initialOwners[0] = owner;
+
+        zoraHookRegistry = new ZoraHookRegistry();
+        zoraHookRegistry.initialize(initialOwners);
+
+        mockHook = new MockHook();
+    }
+
+    function test_register_hooks() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        assertEq(zoraHookRegistry.isRegisteredHook(hooks[0]), true);
+
+        address[] memory addrs = zoraHookRegistry.getHookAddresses();
+        assertEq(addrs.length, 1);
+        assertEq(addrs[0], hooks[0]);
+
+        assertEq(zoraHookRegistry.getHookTag(hooks[0]), tags[0]);
+
+        IZoraHookRegistry.ZoraHook[] memory zoraHooks = zoraHookRegistry.getHooks();
+        assertEq(zoraHooks.length, 1);
+        assertEq(zoraHooks[0].hook, hooks[0]);
+        assertEq(zoraHooks[0].tag, "ZoraHook");
+        assertEq(zoraHooks[0].version, "0.0.0");
+    }
+
+    function test_revert_register_hooks_only_owner() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.expectRevert(abi.encodeWithSignature("OnlyOwner()"));
+        vm.prank(makeAddr("notOwner"));
+        zoraHookRegistry.registerHooks(hooks, tags);
+    }
+
+    function test_revert_register_hooks_array_length_mismatch() public {
+        address[] memory hooks = new address[](2);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        hooks[1] = makeAddr("anotherHook");
+        tags[0] = "Tag0";
+
+        vm.prank(owner);
+        vm.expectRevert(abi.encodeWithSignature("ArrayLengthMismatch()"));
+        zoraHookRegistry.registerHooks(hooks, tags);
+    }
+
+    function test_register_duplicate_is_idempotent() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.startPrank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+        zoraHookRegistry.registerHooks(hooks, tags);
+        vm.stopPrank();
+
+        assertEq(zoraHookRegistry.getHookAddresses().length, 1);
+        assertEq(zoraHookRegistry.isRegisteredHook(hooks[0]), true);
+    }
+
+    function test_remove_hooks() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        vm.prank(owner);
+        zoraHookRegistry.removeHooks(hooks);
+
+        assertEq(zoraHookRegistry.isRegisteredHook(hooks[0]), false);
+        assertEq(zoraHookRegistry.getHookAddresses().length, 0);
+        assertEq(zoraHookRegistry.getHookTag(hooks[0]), "");
+    }
+
+    function test_revert_remove_hooks_only_owner() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        vm.expectRevert(abi.encodeWithSignature("OnlyOwner()"));
+        vm.prank(makeAddr("notOwner"));
+        zoraHookRegistry.removeHooks(hooks);
+    }
+
+    function test_remove_unregistered_noop() public {
+        address[] memory hooks = new address[](1);
+        hooks[0] = makeAddr("unregistered");
+
+        uint256 beforeLen = zoraHookRegistry.getHookAddresses().length;
+
+        vm.prank(owner);
+        zoraHookRegistry.removeHooks(hooks);
+
+        assertEq(zoraHookRegistry.getHookAddresses().length, beforeLen);
+        assertEq(zoraHookRegistry.isRegisteredHook(hooks[0]), false);
+    }
+
+    function test_emit_register_hooks_event() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.expectEmit(true, true, true, false, address(zoraHookRegistry));
+        emit IZoraHookRegistry.ZoraHookRegistered(hooks[0], tags[0], "0.0.0");
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+    }
+
+    function test_emit_remove_hooks_event() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = address(mockHook);
+        tags[0] = "ZoraHook";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        vm.expectEmit(true, true, true, false, address(zoraHookRegistry));
+        emit IZoraHookRegistry.ZoraHookRemoved(hooks[0], tags[0], "0.0.0");
+
+        vm.prank(owner);
+        zoraHookRegistry.removeHooks(hooks);
+    }
+
+    function test_hook_version() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = 0x81542dC43Aff247eff4a0eceFC286A2973aE1040;
+        tags[0] = "CONTENT";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        assertEq(zoraHookRegistry.getHookVersion(hooks[0]), "1.1.1");
+    }
+
+    function test_hook_version_not_found() public {
+        address[] memory hooks = new address[](1);
+        string[] memory tags = new string[](1);
+
+        hooks[0] = 0xA1eBdD5cA6470Bbd67114331387f2dDa7bfad040;
+        tags[0] = "CONTENT";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        assertEq(zoraHookRegistry.getHookVersion(hooks[0]), "");
+    }
+
+    function test_is_registered_hook_false_when_never_registered() public view {
+        assertEq(zoraHookRegistry.isRegisteredHook(address(this)), false);
+    }
+
+    function test_get_hook_addresses_multiple_and_remove_middle() public {
+        address a = address(mockHook);
+        address b = address(new MockHook());
+        address c = address(new MockHook());
+
+        address[] memory hooks = new address[](3);
+        string[] memory tags = new string[](3);
+        hooks[0] = a;
+        tags[0] = "A";
+        hooks[1] = b;
+        tags[1] = "B";
+        hooks[2] = c;
+        tags[2] = "C";
+
+        vm.prank(owner);
+        zoraHookRegistry.registerHooks(hooks, tags);
+
+        address[] memory removeB = new address[](1);
+        removeB[0] = b;
+
+        vm.prank(owner);
+        zoraHookRegistry.removeHooks(removeB);
+
+        address[] memory addrs = zoraHookRegistry.getHookAddresses();
+        assertEq(addrs.length, 2);
+
+        bool hasA;
+        bool hasC;
+        for (uint256 i = 0; i < addrs.length; i++) {
+            if (addrs[i] == a) hasA = true;
+            if (addrs[i] == c) hasC = true;
+            assertTrue(addrs[i] != b);
+        }
+        assertTrue(hasA);
+        assertTrue(hasC);
+
+        assertEq(zoraHookRegistry.getHookTag(a), "A");
+        assertEq(zoraHookRegistry.getHookTag(b), "");
+        assertEq(zoraHookRegistry.getHookTag(c), "C");
+
+        IZoraHookRegistry.ZoraHook[] memory full = zoraHookRegistry.getHooks();
+        assertEq(full.length, 2);
+
+        bool okA;
+        bool okC;
+        for (uint256 i = 0; i < full.length; i++) {
+            if (full[i].hook == a) {
+                assertEq(full[i].tag, "A");
+                assertEq(full[i].version, "0.0.0");
+                okA = true;
+            } else if (full[i].hook == c) {
+                assertEq(full[i].tag, "C");
+                assertEq(full[i].version, "0.0.0");
+                okC = true;
+            }
+        }
+        assertTrue(okA && okC);
+    }
+}

package/test/utils/BaseTest.sol

@@ -24,10 +24,9 @@ import {IUniswapV3Factory} from "../../src/interfaces/IUniswapV3Factory.sol";
 import {IUniswapV3Pool} from "../../src/interfaces/IUniswapV3Pool.sol";
 import {IProtocolRewards} from "../../src/interfaces/IProtocolRewards.sol";
 import {ProtocolRewards} from "../utils/ProtocolRewards.sol";
-import {MarketConstants} from "../../src/libs/MarketConstants.sol";
 import {CoinConfigurationVersions} from "../../src/libs/CoinConfigurationVersions.sol";
 import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
-import {ContentCoinHook} from "../../src/hooks/ContentCoinHook.sol";
+import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
 import {HooksDeployment} from "../../src/libs/HooksDeployment.sol";
 import {CoinConstants} from "../../src/libs/CoinConstants.sol";
 import {ProxyShim} from "./ProxyShim.sol";
@@ -41,15 +40,19 @@ import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
 import {Actions} from "@uniswap/v4-periphery/src/libraries/Actions.sol";
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import {CreatorCoin} from "../../src/CreatorCoin.sol";
-import {CreatorCoinHook} from "../../src/hooks/CreatorCoinHook.sol";
 import {ContractAddresses} from "./ContractAddresses.sol";
 import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
 import {HookUpgradeGate} from "../../src/hooks/HookUpgradeGate.sol";
+import {ZoraHookRegistry} from "../../src/hook-registry/ZoraHookRegistry.sol";
 
 contract BaseTest is Test, ContractAddresses {
     using stdStorage for StdStorage;
 
     int24 internal constant USDC_TICK_LOWER = 57200;
+    int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = CoinConstants.DEFAULT_DISCOVERY_TICK_LOWER;
+    int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = CoinConstants.DEFAULT_DISCOVERY_TICK_UPPER;
+    uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = CoinConstants.DEFAULT_NUM_DISCOVERY_POSITIONS;
+    uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = CoinConstants.DEFAULT_DISCOVERY_SUPPLY_SHARE;
 
     struct Users {
         address factoryOwner;
@@ -85,13 +88,9 @@ contract BaseTest is Test, ContractAddresses {
     CreatorCoin internal creatorCoinImpl;
     ZoraFactoryImpl internal factoryImpl;
     IZoraFactory internal factory;
-    ContentCoinHook internal contentCoinHook;
-    CreatorCoinHook internal creatorCoinHook;
+    ZoraV4CoinHook internal hook;
     HookUpgradeGate internal hookUpgradeGate;
-    int24 internal constant DEFAULT_DISCOVERY_TICK_LOWER = CoinConstants.DEFAULT_DISCOVERY_TICK_LOWER;
-    int24 internal constant DEFAULT_DISCOVERY_TICK_UPPER = CoinConstants.DEFAULT_DISCOVERY_TICK_UPPER;
-    uint16 internal constant DEFAULT_NUM_DISCOVERY_POSITIONS = CoinConstants.DEFAULT_NUM_DISCOVERY_POSITIONS;
-    uint256 internal constant DEFAULT_DISCOVERY_SUPPLY_SHARE = CoinConstants.DEFAULT_DISCOVERY_SUPPLY_SHARE;
+    ZoraHookRegistry internal zoraHookRegistry;
 
     function _defaultPoolConfig(address currency) internal pure returns (bytes memory) {
         return CoinConfigurationVersions.defaultDopplerMultiCurveUniV4(currency);
@@ -203,28 +202,14 @@ contract BaseTest is Test, ContractAddresses {
         vm.stopPrank();
     }
 
-    function _deployFeeEstimatorHook(uint256 initialSupplyForPositions, address hooks) internal {
-        deployCodeTo("FeeEstimatorHook.sol", abi.encode(V4_POOL_MANAGER, address(factory), hookUpgradeGate, initialSupplyForPositions), hooks);
+    function _deployFeeEstimatorHook(address hooks) internal {
+        deployCodeTo("FeeEstimatorHook.sol", abi.encode(V4_POOL_MANAGER, address(factory), hookUpgradeGate), hooks);
     }
 
-    function getSalts(address[] memory trustedMessageSenders) public returns (bytes32 contentCoinSalt, bytes32 creatorCoinSalt) {
+    function getSalt(address[] memory trustedMessageSenders) public returns (bytes32 hookSalt) {
         address deployer = address(this);
 
-        (, contentCoinSalt) = HooksDeployment.mineForContentCoinSalt(
-            deployer,
-            V4_POOL_MANAGER,
-            address(factory),
-            trustedMessageSenders,
-            address(hookUpgradeGate)
-        );
-
-        (, creatorCoinSalt) = HooksDeployment.mineForCreatorCoinSalt(
-            deployer,
-            V4_POOL_MANAGER,
-            address(factory),
-            trustedMessageSenders,
-            address(hookUpgradeGate)
-        );
+        (, hookSalt) = HooksDeployment.mineForCoinSalt(deployer, V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate));
     }
 
     function _deployHooks() internal {
@@ -232,24 +217,14 @@ contract BaseTest is Test, ContractAddresses {
         trustedMessageSenders[0] = UNIVERSAL_ROUTER;
         trustedMessageSenders[1] = V4_POSITION_MANAGER;
 
-        (bytes32 contentCoinSalt, bytes32 creatorCoinSalt) = getSalts(trustedMessageSenders);
+        bytes32 hookSalt = getSalt(trustedMessageSenders);
 
-        contentCoinHook = ContentCoinHook(
-            payable(
-                address(
-                    HooksDeployment.deployHookWithSalt(
-                        HooksDeployment.contentCoinCreationCode(V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate)),
-                        contentCoinSalt
-                    )
-                )
-            )
-        );
-        creatorCoinHook = CreatorCoinHook(
+        hook = ZoraV4CoinHook(
             payable(
                 address(
                     HooksDeployment.deployHookWithSalt(
-                        HooksDeployment.creatorCoinHookCreationCode(V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate)),
-                        creatorCoinSalt
+                        HooksDeployment.makeHookCreationCode(V4_POOL_MANAGER, address(factory), trustedMessageSenders, address(hookUpgradeGate)),
+                        hookSalt
                     )
                 )
             )
@@ -291,13 +266,20 @@ contract BaseTest is Test, ContractAddresses {
 
         hookUpgradeGate = new HookUpgradeGate(users.factoryOwner);
 
+        zoraHookRegistry = new ZoraHookRegistry();
+
+        address[] memory initialOwners = new address[](2);
+        initialOwners[0] = users.factoryOwner;
+        initialOwners[1] = address(factory);
+        zoraHookRegistry.initialize(initialOwners);
+
         _deployHooks();
 
         coinV4Impl = new ContentCoin(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK);
 
         creatorCoinImpl = new CreatorCoin(users.feeRecipient, address(protocolRewards), IPoolManager(V4_POOL_MANAGER), DOPPLER_AIRLOCK);
 
-        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(contentCoinHook), address(creatorCoinHook));
+        factoryImpl = new ZoraFactoryImpl(address(coinV4Impl), address(creatorCoinImpl), address(hook), address(zoraHookRegistry));
         UUPSUpgradeable(address(factory)).upgradeToAndCall(address(factoryImpl), "");
         factory = IZoraFactory(address(factory));
 
@@ -317,7 +299,7 @@ contract BaseTest is Test, ContractAddresses {
         vm.label(address(V4_QUOTER), "V4_QUOTER");
         vm.label(address(V4_PERMIT2), "V4_PERMIT2");
         vm.label(address(UNIVERSAL_ROUTER), "UNIVERSAL_ROUTER");
-        vm.label(address(creatorCoinHook), "CREATOR_COIN_HOOK");
+        vm.label(address(hook), "HOOK");
     }
 
     struct TradeRewards {

package/test/utils/FeeEstimatorHook.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.13;
 
-import {ContentCoinHook} from "../../src/hooks/ContentCoinHook.sol";
+import {ZoraV4CoinHook} from "../../src/hooks/ZoraV4CoinHook.sol";
 import {IPoolManager, PoolKey} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
 import {IDeployedCoinVersionLookup} from "../../src/interfaces/IDeployedCoinVersionLookup.sol";
 import {IHasRewardsRecipients} from "../../src/interfaces/IHasRewardsRecipients.sol";
@@ -15,11 +15,10 @@ import {ICoin, IHasSwapPath} from "../../src/interfaces/ICoin.sol";
 import {UniV4SwapToCurrency} from "../../src/libs/UniV4SwapToCurrency.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {CoinRewardsV4} from "../../src/libs/CoinRewardsV4.sol";
-import {BaseZoraV4CoinHook} from "../../src/hooks/BaseZoraV4CoinHook.sol";
 import {IHooksUpgradeGate} from "../../src/interfaces/IHooksUpgradeGate.sol";
 
 /// @dev Test util - meant to be able to etched where a normal zora hook is, to gather the fees from swaps but not distribute them
-contract FeeEstimatorHook is BaseZoraV4CoinHook {
+contract FeeEstimatorHook is ZoraV4CoinHook {
     struct FeeEstimatorState {
         uint128 fees0;
         uint128 fees1;
@@ -34,9 +33,8 @@ contract FeeEstimatorHook is BaseZoraV4CoinHook {
     constructor(
         IPoolManager _poolManager,
         IDeployedCoinVersionLookup _coinVersionLookup,
-        IHooksUpgradeGate upgradeGate,
-        uint256 initialSupplyForPositions
-    ) BaseZoraV4CoinHook(_poolManager, _coinVersionLookup, new address[](0), upgradeGate, initialSupplyForPositions) {}
+        IHooksUpgradeGate upgradeGate
+    ) ZoraV4CoinHook(_poolManager, _coinVersionLookup, new address[](0), upgradeGate) {}
 
     FeeEstimatorState public feeState;
 

package/test/utils/RewardTestHelpers.sol

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {CoinRewardsV4} from "../../src/libs/CoinRewardsV4.sol";
+import {FeeEstimatorHook} from "./FeeEstimatorHook.sol";
+import {CoinConstants} from "../../src/libs/CoinConstants.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {Vm} from "forge-std/Vm.sol";
+
+// Shared struct to track balance changes for reward recipients
+struct RewardBalances {
+    uint256 creator;
+    uint256 platformReferrer;
+    uint256 tradeReferrer;
+    uint256 protocol;
+    uint256 doppler;
+}
+
+library RewardTestHelpers {
+    Vm private constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
+
+    // Helper function to calculate reward based on BPS
+    function calculateReward(uint256 total, uint256 bps) internal pure returns (uint256) {
+        return (total * bps) / 10_000;
+    }
+
+    function calculateExpectedRewards(
+        uint256 marketRewards,
+        bool hasPlatformReferrer,
+        bool hasTradeReferrer
+    ) internal pure returns (RewardBalances memory rewards) {
+        rewards.creator = calculateReward(marketRewards, CoinConstants.CREATOR_REWARD_BPS);
+        rewards.platformReferrer = hasPlatformReferrer ? calculateReward(marketRewards, CoinConstants.CREATE_REFERRAL_REWARD_BPS) : 0;
+        rewards.tradeReferrer = hasTradeReferrer ? calculateReward(marketRewards, CoinConstants.TRADE_REFERRAL_REWARD_BPS) : 0;
+        rewards.doppler = calculateReward(marketRewards, CoinConstants.DOPPLER_REWARD_BPS);
+        rewards.protocol = marketRewards - rewards.creator - rewards.platformReferrer - rewards.tradeReferrer - rewards.doppler;
+    }
+
+    // Helper function to assert reward distributions match expected RewardBalances
+    function assertRewardsApproxEqRel(RewardBalances memory actual, RewardBalances memory expected) internal pure {
+        vm.assertApproxEqRel(actual.creator, expected.creator, 0.25e18, "Creator reward amount");
+        vm.assertApproxEqRel(actual.platformReferrer, expected.platformReferrer, 0.25e18, "Platform referrer reward amount");
+        vm.assertApproxEqRel(actual.tradeReferrer, expected.tradeReferrer, 0.25e18, "Trade referrer reward amount");
+        vm.assertApproxEqRel(actual.doppler, expected.doppler, 0.25e18, "Doppler reward amount");
+        vm.assertApproxEqRel(actual.protocol, expected.protocol, 0.25e18, "Protocol reward amount");
+    }
+
+    // Helper function to assert with higher tolerance for complex conversions
+    function assertRewardsApproxEqRelWithTolerance(RewardBalances memory actual, RewardBalances memory expected, uint256 tolerance) internal pure {
+        vm.assertApproxEqRel(actual.creator, expected.creator, tolerance, "Creator reward amount");
+        vm.assertApproxEqRel(actual.platformReferrer, expected.platformReferrer, tolerance, "Platform referrer reward amount");
+        vm.assertApproxEqRel(actual.tradeReferrer, expected.tradeReferrer, tolerance, "Trade referrer reward amount");
+        vm.assertApproxEqRel(actual.doppler, expected.doppler, tolerance, "Doppler reward amount");
+        vm.assertApproxEqRel(actual.protocol, expected.protocol, tolerance, "Protocol reward amount");
+    }
+
+    // Generic function to record token balances for all reward recipients
+    function recordBalances(
+        IERC20 token,
+        address creator,
+        address platformReferrer,
+        address tradeReferrer,
+        address protocolRecipient,
+        address dopplerRecipient
+    ) internal view returns (RewardBalances memory balances) {
+        balances.creator = token.balanceOf(creator);
+        balances.platformReferrer = token.balanceOf(platformReferrer);
+        balances.tradeReferrer = token.balanceOf(tradeReferrer);
+        balances.protocol = token.balanceOf(protocolRecipient);
+        balances.doppler = token.balanceOf(dopplerRecipient);
+    }
+
+    // Helper function to calculate reward deltas between two balance snapshots
+    function calculateRewardDeltas(
+        RewardBalances memory initialBalances,
+        RewardBalances memory finalBalances
+    ) internal pure returns (RewardBalances memory deltas) {
+        deltas.creator = finalBalances.creator - initialBalances.creator;
+        deltas.platformReferrer = finalBalances.platformReferrer - initialBalances.platformReferrer;
+        deltas.tradeReferrer = finalBalances.tradeReferrer - initialBalances.tradeReferrer;
+        deltas.protocol = finalBalances.protocol - initialBalances.protocol;
+        deltas.doppler = finalBalances.doppler - initialBalances.doppler;
+    }
+
+    // Helper function to sum total rewards
+    function getTotalRewards(RewardBalances memory rewards) internal pure returns (uint256) {
+        return rewards.creator + rewards.platformReferrer + rewards.tradeReferrer + rewards.protocol + rewards.doppler;
+    }
+
+    // Helper function to calculate reward deltas after trade for any token
+    function calculateTokenRewardDeltas(
+        RewardBalances memory initialBalances,
+        IERC20 token,
+        address creator,
+        address platformReferrer,
+        address tradeReferrer,
+        address protocolRecipient,
+        address dopplerRecipient
+    ) internal view returns (RewardBalances memory deltas) {
+        deltas.creator = token.balanceOf(creator) - initialBalances.creator;
+        deltas.platformReferrer = token.balanceOf(platformReferrer) - initialBalances.platformReferrer;
+        deltas.tradeReferrer = token.balanceOf(tradeReferrer) - initialBalances.tradeReferrer;
+        deltas.protocol = token.balanceOf(protocolRecipient) - initialBalances.protocol;
+        deltas.doppler = token.balanceOf(dopplerRecipient) - initialBalances.doppler;
+    }
+}