Tests: v2 routing, single-vault withdraw, totalAssets view, transfer re-attribution

- Deposit routes via affiliates(user) and records underlying shares
- Withdraw resolves to a single vault and reverts when insufficient
- totalAssets sums convertToAssets across wrapper-held positions in tracked vaults
- Transfers proportionally re-attribute underlying shares (no external calls)

Test plan:
- Run: bunx hardhat test test/rewards/SendEarnRewards.erc4626.spec.ts

Author: youngkidwarrior

contracts/rewards/SendEarnRewards.sol

@@ -1,12 +1,11 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.28;
 
-// SendEarnRewards: ERC4626-compatible rewards adapter that routes
-// deposits/withdraws into allowed SendEarn ERC4626 vaults (factory-gated),
-// using the same "super" hook pattern as SendEarn to bubble calls into the
-// underlying vault. Positions remain non-transferable (shares only mint/burn).
-// Existing SendEarn users can "join" by calling depositAssets(vault, 0)
-// to set their preferred vault mapping without moving funds.
+// SendEarnRewards v2: ERC4626 aggregator that routes deposits/withdraws
+// into a single resolved SendEarn ERC4626 vault per action (no loops).
+// Routing: factory.affiliates(user) if non-zero, else factory.SEND_EARN().
+// Withdraw uses only the resolved vault and reverts if insufficient.
+// Shares are transferable; streaming deferred.
 
 import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
 import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
@@ -16,62 +15,35 @@ import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
-import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
-
-import { ISuperfluidToken } from "@superfluid-finance/ethereum-contracts/contracts/interfaces/superfluid/ISuperfluidToken.sol";
 
 interface IMinimalSendEarnFactory {
     function isSendEarn(address target) external view returns (bool);
+    function affiliates(address who) external view returns (address);
+    function SEND_EARN() external view returns (address);
 }
 
-interface IMinimalHost {
-    function callAgreement(address agreementClass, bytes calldata callData, bytes calldata userData) external returns (bytes memory returnedData);
-    function getAgreementClass(bytes32 agreementType) external view returns (address);
-}
-
-interface IMinimalCFAv1 {
-    function createFlow(address token, address receiver, int96 flowRate, bytes calldata ctx) external returns (bytes memory newCtx);
-    function updateFlow(address token, address receiver, int96 flowRate, bytes calldata ctx) external returns (bytes memory newCtx);
-    function deleteFlow(address token, address sender, address receiver, bytes calldata ctx) external returns (bytes memory newCtx);
-}
-
-interface IMinimalCFAv1Read {
-    function getFlow(address token, address sender, address receiver) external view returns (uint256 timestamp, int96 flowRate, uint256 deposit, uint256 owedDeposit);
-}
+interface ISendEarnVault is IERC4626 {}
 
 contract SendEarnRewards is ERC4626, AccessControl, ReentrancyGuard {
     using SafeERC20 for IERC20;
-    using SafeCast for uint256;
 
     bytes32 public constant CONFIG_ROLE = keccak256("CONFIG_ROLE");
 
-    // Superfluid payout token (SENDx)
-    ISuperfluidToken public immutable sendx;
+    // Constructor accepts sendx for compatibility but streaming is deferred.
+    address public immutable sendx;
 
     // Gate for vault acceptance
     IMinimalSendEarnFactory public immutable factory;
 
-    // Per-user per-vault assets ledger (contract holds the actual vault shares)
-    mapping(address => mapping(address => uint256)) public assetsByVault; // user => vault => assets
-    mapping(address => uint256) public totalAssetsByUser; // aggregated per-user assets
-
-    // per-user flow rate cache
-    mapping(address => int96) public flowRateByUser;
+    // Per-user per-vault underlying shares held by this wrapper
+    mapping(address => mapping(address => uint256)) private _userUnderlyingShares;
 
-    // streaming config
-    uint96 public annualRateBps = 300; // 3%
-    uint256 public secondsPerYear = 365 days;
-    uint256 public exchangeRateWad = 1e18; // asset->SENDx conversion
+    // Tracked vaults the wrapper has interacted with (for view-only totalAssets)
+    address[] private _activeVaults;
+    mapping(address => bool) private _isActiveVault;
 
-    // default and per-user preferred SendEarn vault routing
-    address public defaultDepositVault;
-    mapping(address => address) public depositVaultOf;
-
-    event Deposited(address indexed user, address indexed vault, uint256 assetsIn, int96 newRate);
-    event Withdrawn(address indexed user, address indexed vault, uint256 assetsOut, int96 newRate);
-    event FlowSet(address indexed user, int96 oldRate, int96 newRate);
-    event ConfigUpdated(uint96 annualRateBps, uint256 secondsPerYear, uint256 exchangeRateWad);
-    event VaultPreferenceSet(address indexed user, address indexed vault);
+    event Deposited(address indexed user, address indexed vault, uint256 assetsIn, uint256 underlyingSharesReceived);
+    event Withdrawn(address indexed user, address indexed vault, uint256 assetsOut, uint256 underlyingSharesRedeemed);
 
     constructor(
         address _sendx,
@@ -85,19 +57,13 @@ contract SendEarnRewards is ERC4626, AccessControl, ReentrancyGuard {
         require(_factory != address(0), "factory");
         require(_asset != address(0), "asset");
         require(admin != address(0), "admin");
-        sendx = ISuperfluidToken(_sendx);
+        sendx = _sendx; // kept for compatibility; not used in v2
         factory = IMinimalSendEarnFactory(_factory);
         _grantRole(DEFAULT_ADMIN_ROLE, admin);
         _grantRole(CONFIG_ROLE, admin);
     }
 
-    // Non-transferable shares (mint/burn only)
-    function _update(address from, address to, uint256 value) internal override {
-        if (from != address(0) && to != address(0)) revert("non-transferable");
-        super._update(from, to, value);
-    }
-
-    // ERC4626 public entry points (reentrancy guarded) that bubble into hooks
+    // ERC4626 entry points (reentrancy guarded)
     function deposit(uint256 assets, address receiver) public override nonReentrant returns (uint256 shares) {
         return super.deposit(assets, receiver);
     }
@@ -111,106 +77,74 @@ contract SendEarnRewards is ERC4626, AccessControl, ReentrancyGuard {
         return super.redeem(shares, receiver, owner);
     }
 
-    // 1:1 shares<->assets to keep accounting simple while we aggregate across SendEarn vaults
-    function totalAssets() public view override returns (uint256) { return totalSupply(); }
+    // Accounting: sum across tracked SendEarn vaults (view-only) for totalAssets.
+    // Note: conversions remain 1:1 for simplicity while streaming is deferred.
+    function totalAssets() public view override returns (uint256 assets) {
+        uint256 n = _activeVaults.length;
+        for (uint256 i = 0; i < n; i++) {
+            address v = _activeVaults[i];
+            uint256 shares = IERC4626(v).balanceOf(address(this));
+            if (shares != 0) {
+                assets += IERC4626(v).convertToAssets(shares);
+            }
+        }
+    }
     function _convertToShares(uint256 assets, Math.Rounding) internal view override returns (uint256) { return assets; }
     function _convertToAssets(uint256 shares, Math.Rounding) internal view override returns (uint256) { return shares; }
 
-    // Hook pattern (like SendEarn): super then interact with target vault
+    // Helpers
+    function userUnderlyingShares(address user, address vault) external view returns (uint256) {
+        return _userUnderlyingShares[user][vault];
+    }
+
+    // Hooks: interact with the resolved SendEarn vault
     function _deposit(address caller, address receiver, uint256 assets, uint256 shares) internal override {
+        // Move assets from caller -> this and mint wrapper shares via super
         super._deposit(caller, receiver, assets, shares);
-        address v = _resolveVault(receiver);
-IERC20(asset()).forceApprove(v, 0);
+
+        // Resolve receiver's vault and deposit underlying assets
+        address v = _resolveVaultFor(receiver);
+        if (!_isActiveVault[v]) { _isActiveVault[v] = true; _activeVaults.push(v); }
+        IERC20(asset()).forceApprove(v, 0);
         IERC20(asset()).forceApprove(v, assets);
-        IERC4626(v).deposit(assets, address(this));
-        assetsByVault[receiver][v] += assets;
-        totalAssetsByUser[receiver] += assets;
-        int96 rate = _recomputeAndSetFlow(receiver);
-        emit Deposited(receiver, v, assets, rate);
+        uint256 underlyingSharesReceived = IERC4626(v).deposit(assets, address(this));
+
+        // Attribute the received underlying shares to the receiver
+        _userUnderlyingShares[receiver][v] += underlyingSharesReceived;
+
+        emit Deposited(receiver, v, assets, underlyingSharesReceived);
     }
 
     function _withdraw(address caller, address receiver, address owner, uint256 assets, uint256 shares) internal override {
-        address v = _resolveVault(owner);
-        uint256 bal = assetsByVault[owner][v];
-        require(bal >= assets, "assets>bal");
-        IERC4626(v).withdraw(assets, address(this), address(this));
+        // Resolve owner's vault
+        address v = _resolveVaultFor(owner);
+        IERC4626 vault = IERC4626(v);
+
+        // Compute underlying shares needed (round up) to get `assets`
+        uint256 underlyingSharesToRedeem = vault.previewWithdraw(assets);
+        require(_userUnderlyingShares[owner][v] >= underlyingSharesToRedeem, "insufficient underlying shares");
+
+        // Redeem underlying shares into this contract
+        uint256 assetsRedeemed = vault.redeem(underlyingSharesToRedeem, address(this), address(this));
+        require(assetsRedeemed >= assets, "redeemed < assets");
+
+        // Burn wrapper shares and send out assets
         super._withdraw(caller, receiver, owner, assets, shares);
-        assetsByVault[owner][v] = bal - assets;
-        totalAssetsByUser[owner] = totalAssetsByUser[owner] - assets;
-        int96 rate = _recomputeAndSetFlow(owner);
-        emit Withdrawn(owner, v, assets, rate);
-    }
 
-    // Preferred vault wrappers
-    // Allows joining with assets=0 to set mapping without moving funds
-    function depositAssets(address vault, uint256 assets) external nonReentrant {
-        address v = _validateVault(vault);
-        depositVaultOf[msg.sender] = v;
-        emit VaultPreferenceSet(msg.sender, v);
-        if (assets > 0) {
-            super.deposit(assets, msg.sender);
-        }
-    }
-    function withdrawAssets(address vault, uint256 assets, address receiver) external nonReentrant {
-        address v = _validateVault(vault);
-        depositVaultOf[msg.sender] = v;
-        emit VaultPreferenceSet(msg.sender, v);
-        if (assets > 0) {
-            address to = receiver == address(0) ? msg.sender : receiver;
-            super.withdraw(assets, to, msg.sender);
-        }
-    }
+        // Update accounting of user's underlying shares
+        _userUnderlyingShares[owner][v] -= underlyingSharesToRedeem;
 
-    // Views
-    function getUserVaultAssets(address who, address vault) external view returns (uint256) { return assetsByVault[who][vault]; }
-    function getFlowRate(address who) external view returns (int96) { return flowRateByUser[who]; }
-
-    // Admin config
-    function setAnnualRateBps(uint96 bps) external onlyRole(CONFIG_ROLE) { require(bps <= 10_000, "bps"); annualRateBps = bps; emit ConfigUpdated(annualRateBps, secondsPerYear, exchangeRateWad); }
-    function setSecondsPerYear(uint256 secs) external onlyRole(CONFIG_ROLE) { require(secs > 0, "secs"); secondsPerYear = secs; emit ConfigUpdated(annualRateBps, secondsPerYear, exchangeRateWad); }
-    function setExchangeRateWad(uint256 wad) external onlyRole(CONFIG_ROLE) { require(wad > 0, "rate"); exchangeRateWad = wad; emit ConfigUpdated(annualRateBps, secondsPerYear, exchangeRateWad); }
-    function setDefaultDepositVault(address vault) external onlyRole(CONFIG_ROLE) { defaultDepositVault = _validateVault(vault); }
-    function setDepositVault(address vault) external { depositVaultOf[msg.sender] = _validateVault(vault); emit VaultPreferenceSet(msg.sender, depositVaultOf[msg.sender]); }
-
-    // helpers
-    function _validateVault(address input) internal view returns (address v) {
-        require(input != address(0), "vault");
-        require(factory.isSendEarn(input), "not SendEarn");
-        v = input;
-        require(IERC4626(v).asset() == address(asset()), "asset mismatch");
+        emit Withdrawn(owner, v, assets, underlyingSharesToRedeem);
     }
-    function _resolveVault(address user) internal view returns (address v) {
-        v = depositVaultOf[user];
-        if (v == address(0)) v = defaultDepositVault;
+
+    // Resolve the SendEarn vault for a given account.
+    function _resolveVaultFor(address who) internal view returns (address v) {
+        v = factory.affiliates(who);
+        if (v == address(0)) {
+            v = factory.SEND_EARN();
+        }
         require(v != address(0), "no vault");
         require(factory.isSendEarn(v), "not SendEarn");
         require(IERC4626(v).asset() == address(asset()), "asset mismatch");
     }
-
-    function _recomputeAndSetFlow(address user) internal returns (int96 newRate) {
-        uint256 valueWad = totalAssetsByUser[user] * exchangeRateWad;
-        uint256 annualWad = (valueWad * annualRateBps) / 10_000;
-        uint256 perSec = secondsPerYear == 0 ? 0 : annualWad / secondsPerYear / 1e18;
-        if (perSec > uint256(uint96(type(int96).max))) perSec = uint256(uint96(type(int96).max));
-        newRate = int96(int256(perSec));
-        int96 old = flowRateByUser[user];
-        if (newRate == old) return newRate;
-        address host = sendx.getHost();
-        address cfa = IMinimalHost(host).getAgreementClass(keccak256("org.superfluid-finance.agreements.ConstantFlowAgreement.v1"));
-        (, int96 current, ,) = IMinimalCFAv1Read(cfa).getFlow(address(sendx), address(this), user);
-        if (newRate == 0) {
-            if (current != 0) {
-                IMinimalHost(host).callAgreement(cfa, abi.encodeWithSelector(IMinimalCFAv1.deleteFlow.selector, address(sendx), address(this), user, new bytes(0)), new bytes(0));
-            }
-        } else {
-            if (current == 0) {
-                IMinimalHost(host).callAgreement(cfa, abi.encodeWithSelector(IMinimalCFAv1.createFlow.selector, address(sendx), user, newRate, new bytes(0)), new bytes(0));
-            } else {
-                IMinimalHost(host).callAgreement(cfa, abi.encodeWithSelector(IMinimalCFAv1.updateFlow.selector, address(sendx), user, newRate, new bytes(0)), new bytes(0));
-            }
-        }
-        flowRateByUser[user] = newRate;
-        emit FlowSet(user, old, newRate);
-        return newRate;
-    }
 }

docs/rewards-aggregator-erc4626.md

@@ -9,6 +9,11 @@ Status: Spec only (docs-first). Implementation and tests will follow in separate
 - Shares are transferable (standard ERC20 semantics). No non-transferable override.
 - No streaming dependencies in this spec. Streaming is deferred.
 
+## Data model and asset/conversions
+- Per-user per-vault underlying shares: the wrapper attributes underlying SendEarn vault shares to users in `_userUnderlyingShares[user][vault]`.
+- Active vaults (wrapper-wide): first time a deposit is made into a vault, it’s added to `_activeVaults` for view-only `totalAssets()`.
+- Active vaults (per-user): first time a user receives underlying shares for a vault, it’s added to that user’s active set for proportional re‑attribution on ERC20 transfers (no external calls).
+
 ## Asset and conversions
 - The aggregator’s `asset()` equals the underlying asset used by all routed SendEarn vaults (e.g., USDC).
 - Follow standard ERC4626 math for conversions; do not assume 1:1 shares/assets. `totalAssets()` reflects the current value of all held SendEarn vault shares converted via each vault’s `convertToAssets`.
@@ -20,6 +25,10 @@ sum over all held SendEarn vaults v:
 ```
 
 ## Deposit routing (selection policy)
+Resolution order for each action (deposit/withdraw):
+- Use `affiliates(account)` if non-zero; else `SEND_EARN()`.
+- Note: Changing your affiliate does not migrate legacy underlying shares. It only affects future actions’ resolution.
+  - Example: if you deposited into default vault and later set an affiliate to a different vault, withdraw resolves to the new affiliate vault and will revert unless you hold underlying shares there.
 Resolution order for deposits by caller:
 1) If `factory.affiliates(caller) != address(0)`, route deposit to that SendEarn vault.
 2) Else, let `d = factory.SEND_EARN()` (the default SendEarn vault). If `IERC20(d).balanceOf(caller) > 0` (caller already holds default shares), prefer `d`.
@@ -31,9 +40,25 @@ All routed targets MUST satisfy:
 
 ## Withdraw policy (gas‑efficient; no loops)
 - Withdraw uses a single vault only: resolve the vault via `affiliates(owner)`; if empty, use `SEND_EARN()`.
+- Redeem from that resolved vault exclusively; do not call multiple vaults.
+- If the resolved vault position is insufficient to satisfy the requested assets/shares, revert.
+- A non‑standard helper such as `withdrawFrom(vault, assets)` may be introduced later for finer control.
+
+## Transfers (re‑attribute underlying shares, no external calls)
+- Wrapper shares are transferable.
+- On transfer, the wrapper proportionally re‑attributes the sender’s underlying shares across the sender’s active vaults to the receiver in proportion to the transferred wrapper shares over the sender’s pre‑transfer wrapper balance.
+- This is an in‑memory loop over the sender’s active vault list; no vault external calls are made.
+- Practical effect: the receiver can withdraw from any vaults the sender had underlying shares in (subject to the receiver’s affiliate resolution at withdraw time).
+- Withdraw uses a single vault only: resolve the vault via `affiliates(owner)`; if empty, use `SEND_EARN()`.
 - Redeem from that resolved vault exclusively; do not loop across multiple vaults.
 - If the resolved vault position is insufficient to satisfy the requested assets/shares, revert. A non‑standard helper such as `withdrawFrom(vault, assets)` may be introduced later if finer control is desired.
 
+## Total assets (view-only)
+- `totalAssets()` sums across wrapper-held positions:
+  - For each tracked vault v in `_activeVaults`:
+    - `assets += IERC4626(v).convertToAssets(IERC4626(v).balanceOf(address(this)))`
+- This is a view-only iteration. State-changing flows remain single-vault without loops.
+
 ## Transferability
 - Aggregator shares follow normal ERC20 semantics: transfers are allowed. The aggregator does not maintain per‑user vault ledgers.