Dev

.prettierignore

@@ -12,7 +12,6 @@ types
 .venv
 protocol-costs
 contracts/test
-test/fixtures
 
 # files
 *.env

README.md

@@ -2,8 +2,7 @@
 
 <img src="./assets/Orion_Logo_white_horizontal.png" alt="orion" width="75%">
 
-
-[![codecov][codecov-badge]][codecov] [![Sourcery][sourcery-badge]][sourcery] [![Github Actions][gha-badge]][gha] [![Hardhat][hardhat-badge]][hardhat] 
+ [![Github Actions][gha-badge]][gha] [![Hardhat][hardhat-badge]][hardhat] [![CodeRabbit][cr-badge]][cr]
 
 [![LinkedIn][linkedin-badge]][linkedin] [![X][x-badge]][x] [![Telegram][telegram-badge]][telegram] [![Discord][discord-badge]][discord]
 
@@ -14,11 +13,8 @@
 [hardhat]: https://hardhat.org/
 [hardhat-badge]: https://img.shields.io/badge/Built%20with-Hardhat-FFDB1C.svg
 
-[codecov]: https://codecov.io/gh/OrionFinanceAI/protocol
-[codecov-badge]: https://codecov.io/gh/OrionFinanceAI/protocol/branch/main/graph/badge.svg
-
-[sourcery]: https://sourcery.ai
-[sourcery-badge]: https://img.shields.io/badge/Sourcery-enabled-brightgreen
+[cr]: https://www.coderabbit.ai/
+[cr-badge]: https://img.shields.io/badge/CodeRabbit-Enabled-FF570A?logo=data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTEyIDJMMiAyMkgyMkwxMiAyWiIgZmlsbD0id2hpdGUiLz4KPC9zdmc+
 
 [linkedin]: https://www.linkedin.com/company/orionfinance/
 [linkedin-badge]: https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white

contracts/LiquidityOrchestrator.sol

@@ -31,7 +31,7 @@
  *      - Handling slippage and market execution differences from adapter price estimates via liquidity buffer.
  * @custom:security-contact security@orionfinance.ai
  */
 contract LiquidityOrchestrator is
     Initializable,
     Ownable2StepUpgradeable,
     ReentrancyGuardUpgradeable,
@@ -92,9 +92,6 @@
     /// @notice Current minibatch index
     uint8 public currentMinibatchIndex;
 
-    /// @notice Whether epoch protocol fees have been accrued this epoch
-    bool private epochFeesAccrued;
-
     /// @notice Target buffer ratio
     uint256 public targetBufferRatio;
 
@@ -123,6 +120,17 @@
     /// @notice Tokens that failed during the current epoch's sell/buy execution (cleared at epoch end)
     address[] private _failedEpochTokens;
 
+    /// @notice Cached assets hash from last full commitment build
+    bytes32 private _cachedAssetsHash;
+    /// @notice Cached vaults hash from last full commitment build
+    bytes32 private _cachedVaultsHash;
+
+    /// @notice Buffer amount after each execution minibatch for market impact tracking.
+    uint256[] private _epochBufferHistory;
+
+    /// @notice Epoch protocol fees to accrue when transitioning to ProcessVaultOperations.
+    uint256 private _pendingEpochProtocolFees;
+
     /// @notice Struct to hold epoch state data
     struct EpochState {
         /// @notice Transparent vaults associated to the current epoch
@@ -355,6 +363,11 @@
         return _failedEpochTokens;
     }
 
+    /// @inheritdoc ILiquidityOrchestrator
+    function getEpochBufferHistory() external view returns (uint256[] memory) {
+        return _epochBufferHistory;
+    }
+
     /* -------------------------------------------------------------------------- */
     /*                                CONFIG FUNCTIONS                            */
     /* -------------------------------------------------------------------------- */
@@ -444,20 +457,20 @@
         if (currentPhase == LiquidityUpkeepPhase.Idle && _shouldTriggerUpkeep()) {
             _handleStart();
         } else if (currentPhase == LiquidityUpkeepPhase.StateCommitment) {
-            _currentEpoch.epochStateCommitment = _buildEpochStateCommitment();
+            (bytes32 commitment, bytes32 assetsHash, bytes32 vaultsHash) = _buildEpochStateCommitmentAndComponents();
+            _currentEpoch.epochStateCommitment = commitment;
+            _cachedAssetsHash = assetsHash;
+            _cachedVaultsHash = vaultsHash;
             currentPhase = LiquidityUpkeepPhase.SellingLeg;
             emit EventsLib.EpochStateCommitted(epochCounter, _currentEpoch.epochStateCommitment);
         } else if (currentPhase == LiquidityUpkeepPhase.SellingLeg) {
             StatesStruct memory states = _verifyPerformData(_publicValues, proofBytes, statesBytes);
 
-            if (currentMinibatchIndex == 0 && !epochFeesAccrued) {
-                // Update buffer amount
+            if (currentMinibatchIndex == 0) {
                 bufferAmount = states.bufferAmount;
-                // Accrue protocol fees once per epoch
-                pendingProtocolFees += states.epochProtocolFees;
-                emit EventsLib.ProtocolFeesAccrued(states.epochProtocolFees);
-                epochFeesAccrued = true;
+                _pendingEpochProtocolFees = states.epochProtocolFees;
             }
+            _recordBufferCheckpoint();
 
             _processMinibatchSell(states.sellLeg);
         } else if (currentPhase == LiquidityUpkeepPhase.BuyingLeg) {
@@ -494,6 +507,8 @@
             return;
         }
 
+        _recordBufferCheckpoint();
+
         currentPhase = LiquidityUpkeepPhase.StateCommitment;
 
         // Snapshot protocol fees at epoch start to ensure consistency throughout the epoch
@@ -528,23 +543,23 @@
         }
     }
 
-    /// @notice Builds an epoch state commitment from the full epoch state
-    /// @dev Uses domain separation for cryptographic robustness.
-    /// @return The epoch state commitment
-    function _buildEpochStateCommitment() internal view returns (bytes32) {
+    /// @notice Builds the epoch state commitment and returns assets/vaults hashes for incremental refresh on failure
+    /// @return commitment The full epoch state commitment
+    /// @return assetsHash Cached so on sell/buy failure we can recompute only protocolStateHash
+    /// @return vaultsHash Cached so on sell/buy failure we can recompute only protocolStateHash
+    function _buildEpochStateCommitmentAndComponents()
+        internal
+        view
+        returns (bytes32 commitment, bytes32 assetsHash, bytes32 vaultsHash)
+    {
         address[] memory assets = config.getAllWhitelistedAssets();
         uint256[] memory assetPrices = getAssetPrices(assets);
         VaultStateData memory vaultData = _getVaultStateData();
 
         bytes32 protocolStateHash = _buildProtocolStateHash();
-
-        bytes32 assetsHash = _aggregateAssetLeaves(assets, assetPrices);
-
-        bytes32 vaultsHash = _aggregateVaultLeaves(vaultData);
-
-        bytes32 epochStateCommitment = keccak256(abi.encode(protocolStateHash, assetsHash, vaultsHash));
-
-        return epochStateCommitment;
+        assetsHash = _aggregateAssetLeaves(assets, assetPrices);
+        vaultsHash = _aggregateVaultLeaves(vaultData);
+        commitment = keccak256(abi.encode(protocolStateHash, assetsHash, vaultsHash));
     }
 
     /// @notice Builds the protocol state hash from static epoch parameters
@@ -556,14 +571,16 @@
                 _currentEpoch.activeRsFeeCoefficient,
                 config.maxFulfillBatchSize(),
                 targetBufferRatio,
-                bufferAmount,
                 config.priceAdapterDecimals(),
                 config.strategistIntentDecimals(),
                 epochDuration,
                 config.getAllWhitelistedAssets(),
                 config.getAllTokenDecimals(),
                 config.riskFreeRate(),
-                config.decommissioningAssets()
+                config.decommissioningAssets(),
+                _failedEpochTokens,
+                _epochBufferHistory,
+                bufferAmount
             )
         );
         return protocolStateHash;
@@ -700,17 +717,20 @@
             address token = sellLeg.sellingTokens[i];
             if (token == address(underlyingAsset)) continue;
             uint256 amount = sellLeg.sellingAmounts[i];
             try this._executeSell(token, amount, sellLeg.sellingEstimatedUnderlyingAmounts[i]) {
                 // successful execution, continue.
             } catch {
                 _failedEpochTokens.push(token);
-                // Incremental update of the epoch state commitment to avoid re-running the entire epoch execution.
-                _currentEpoch.epochStateCommitment = keccak256(abi.encode(_currentEpoch.epochStateCommitment, token));
+                _recordBufferCheckpoint();
+                _currentEpoch.epochStateCommitment = keccak256(
+                    abi.encode(_buildProtocolStateHash(), _cachedAssetsHash, _cachedVaultsHash)
+                );
                 emit EventsLib.EpochStateCommitted(epochCounter, _currentEpoch.epochStateCommitment);
                 return;
             }
         }
 
+        _recordBufferCheckpoint();
         ++currentMinibatchIndex;
         if (i1 == sellLeg.sellingTokens.length) {
             currentMinibatchIndex = 0;
@@ -733,19 +753,25 @@
             address token = buyLeg.buyingTokens[i];
             if (token == address(underlyingAsset)) continue;
             uint256 amount = buyLeg.buyingAmounts[i];
             try this._executeBuy(token, amount, buyLeg.buyingEstimatedUnderlyingAmounts[i]) {
                 // successful execution, continue.
             } catch {
                 _failedEpochTokens.push(token);
-                // Incremental update of the epoch state commitment to avoid re-running the entire epoch execution.
-                _currentEpoch.epochStateCommitment = keccak256(abi.encode(_currentEpoch.epochStateCommitment, token));
+                _recordBufferCheckpoint();
+                _currentEpoch.epochStateCommitment = keccak256(
+                    abi.encode(_buildProtocolStateHash(), _cachedAssetsHash, _cachedVaultsHash)
+                );
                 emit EventsLib.EpochStateCommitted(epochCounter, _currentEpoch.epochStateCommitment);
                 return;
             }
         }
 
+        _recordBufferCheckpoint();
         ++currentMinibatchIndex;
         if (i1 == buyLeg.buyingTokens.length) {
+            pendingProtocolFees += _pendingEpochProtocolFees;
+            emit EventsLib.ProtocolFeesAccrued(_pendingEpochProtocolFees);
+            _pendingEpochProtocolFees = 0;
             currentMinibatchIndex = 0;
             currentPhase = LiquidityUpkeepPhase.ProcessVaultOperations;
         }
@@ -761,6 +787,14 @@
         }
     }
 
+    /// @notice Records the current buffer amount as a checkpoint only if it differs from the last entry.
+    function _recordBufferCheckpoint() internal {
+        uint256 n = _epochBufferHistory.length;
+        if (n == 0 || _epochBufferHistory[n - 1] != bufferAmount) {
+            _epochBufferHistory.push(bufferAmount);
+        }
+    }
+
     /// @notice Calculate maximum amount with slippage applied
     /// @param estimatedAmount The estimated amount
     /// @return The maximum amount with slippage applied
@@ -837,12 +871,12 @@
             i1 = uint16(vaultsEpoch.length);
             currentPhase = LiquidityUpkeepPhase.Idle;
             currentMinibatchIndex = 0;
-            epochFeesAccrued = false;
             _nextUpdateTime = block.timestamp + epochDuration;
             emit EventsLib.EpochEnd(epochCounter);
             ++epochCounter;
 
             delete _failedEpochTokens;
+            delete _epochBufferHistory;
         }
 
         for (uint16 i = i0; i < i1; ++i) {

contracts/interfaces/ILiquidityOrchestrator.sol

@@ -122,6 +122,10 @@ interface ILiquidityOrchestrator {
     /// @return List of token addresses that failed
     function getFailedEpochTokens() external view returns (address[] memory);
 
+    /// @notice Returns the buffer amount after each execution minibatch for market impact tracking.
+    /// @return Buffer amount after each minibatch
+    function getEpochBufferHistory() external view returns (uint256[] memory);
+
     /// @notice Gets asset prices for the epoch
     /// @param assets Array of asset addresses
     /// @return assetPrices Array of asset prices

contracts/interfaces/IOrionStrategist.sol

@@ -1,16 +1,18 @@
 // SPDX-License-Identifier: BUSL-1.1
 pragma solidity ^0.8.28;
 
-import "./IOrionTransparentVault.sol";
+import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
 
 /// @title IOrionStrategist
-/// @notice Interface for strategies that compute portfolio intents on-demand
+/// @notice Interface for smart contract strategists that compute portfolio intents on-demand.
 /// @author Orion Finance
-/// @dev Strategists can be smart contracts that implement this interface to provide
-///      dynamic portfolio allocation logic in a fully transparent manner.
+/// @dev Implementors must support ERC-165 so that vaults can detect and auto-link them on assignment.
 /// @custom:security-contact security@orionfinance.ai
-interface IOrionStrategist {
-    /// @notice Submit the current portfolio intent based on market conditions and logic.
-    /// @param vault The vault to submit the intent to
-    function submitIntent(IOrionTransparentVault vault) external;
+interface IOrionStrategist is IERC165 {
+    /// @notice Link this strategist to a vault. Can only be called once per deployment.
+    /// @param vault_ The vault address to link to this strategist.
+    function setVault(address vault_) external;
+
+    /// @notice Compute the current portfolio intent from on-chain state and submit it to the linked vault.
+    function submitIntent() external;
 }

contracts/interfaces/IOrionVault.sol

@@ -207,6 +207,16 @@ interface IOrionVault is IERC4626 {
     /// @dev This returns share amounts, not underlying asset amounts
     function pendingRedeem(uint256 fulfillBatchSize) external view returns (uint256);
 
+    /// @notice Get the list of pending redeem entries (users and shares) for the next fulfill batch
+    /// @param fulfillBatchSize The maximum number of requests to consider
+    /// @return users Addresses with pending redeem requests in batch order
+    /// @return shares Share amounts per user (same index as users)
+    /// @dev This function enables per-request convertToAssetsWithPITTotalAssets calculations,
+    ///      ensuring exact rounding behaviour for state transition.
+    function pendingRedeemBatch(
+        uint256 fulfillBatchSize
+    ) external view returns (address[] memory users, uint256[] memory shares);
+
     /// @notice Calculate the vault's fee based on total assets using a specific fee model
     /// @param totalAssets The total assets under management
     /// @param snapshotFeeModel The fee model to use for calculation (typically from epoch snapshot)

contracts/libraries/ErrorsLib.sol

@@ -101,4 +101,7 @@ library ErrorsLib {
     /// @param proofCommitment The commitment from the zk proof.
     /// @param onchainCommitment The commitment from the onchain.
     error CommitmentMismatch(bytes32 proofCommitment, bytes32 onchainCommitment);
+
+    /// @notice Strategist is already linked to a vault and cannot be re-linked.
+    error StrategistVaultAlreadyLinked();
 }