Adapter execution

.github/workflows/ci.yml

@@ -50,8 +50,35 @@ jobs:
           echo "## Lint results" >> $GITHUB_STEP_SUMMARY
           echo "✅ Passed" >> $GITHUB_STEP_SUMMARY
 
-      - name: "Run tests and generate coverage report"
+      - name: "Run mainnet fork tests"
+        run:
+          pnpm test test/crossAsset/ChainlinkPriceAdapter.test.ts test/crossAsset/ERC4626PriceAdapter.test.ts
+          test/crossAsset/ERC4626ExecutionAdapter.test.ts
+        env:
+          RPC_URL: ${{ secrets.RPC_URL }}
+          DEPLOYER_PRIVATE_KEY: ${{ secrets.DEPLOYER_PRIVATE_KEY }}
+          LP_PRIVATE_KEY: ${{ secrets.LP_PRIVATE_KEY }}
+          ETHERSCAN_API_KEY: ${{ secrets.ETHERSCAN_API_KEY }}
+          FORK_MAINNET: "true"
+          MAINNET_RPC_URL: ${{ secrets.MAINNET_RPC_URL }}
+
+      - name: "Run unit tests"
+        run: pnpm test
+        env:
+          RPC_URL: ${{ secrets.RPC_URL }}
+          DEPLOYER_PRIVATE_KEY: ${{ secrets.DEPLOYER_PRIVATE_KEY }}
+          LP_PRIVATE_KEY: ${{ secrets.LP_PRIVATE_KEY }}
+          ETHERSCAN_API_KEY: ${{ secrets.ETHERSCAN_API_KEY }}
+
+      - name: "Generate coverage report"
         run: pnpm coverage
+        env:
+          RPC_URL: ${{ secrets.RPC_URL }}
+          DEPLOYER_PRIVATE_KEY: ${{ secrets.DEPLOYER_PRIVATE_KEY }}
+          LP_PRIVATE_KEY: ${{ secrets.LP_PRIVATE_KEY }}
+          ETHERSCAN_API_KEY: ${{ secrets.ETHERSCAN_API_KEY }}
+          FORK_MAINNET: "true"
+          MAINNET_RPC_URL: ${{ secrets.MAINNET_RPC_URL }}
 
       - name: "Upload coverage to Codecov"
         uses: codecov/codecov-action@v5
@@ -147,7 +174,6 @@ jobs:
 
           find artifacts/contracts -name "*.json" \
             ! -name "*.dbg.json" \
-            ! -path "*/mocks/*" \
             ! -path "*/test/*" \
             -exec sh -c '
               for file do

.gitignore

@@ -26,6 +26,7 @@ docs/
 res/
 running_node/
 artifacts/
+edr-cache/
 
 scripts/*.ts
 

.solhintignore

@@ -1,6 +1,5 @@
 # directories
 **/artifacts
 **/node_modules
-contracts/mocks
 contracts/test
 contracts/sp1-contracts

codecov.yml

@@ -15,7 +15,6 @@ coverage:
 
   ignore:
     - "test/**"
-    - "**/mocks/**"
     - "**/*.t.sol"
     - "artifacts/**"
     - "audits/**"

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,
@@ -169,6 +169,7 @@
     }
 
     /// @dev Restricts function to only self
+    ///      Used on _executeSell and _executeBuy so they can stay external (required for try/catch)
     modifier onlySelf() {
         if (msg.sender != address(this)) revert ErrorsLib.NotAuthorized();
         _;
@@ -284,6 +285,7 @@
 
     /// @inheritdoc ILiquidityOrchestrator
     function setSlippageTolerance(uint256 _slippageTolerance) external onlyOwner {
+        if (_slippageTolerance > BASIS_POINTS_FACTOR) revert ErrorsLib.InvalidArguments();
         slippageTolerance = _slippageTolerance;
     }
 
@@ -697,7 +699,7 @@
             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 {
                 currentPhase = LiquidityUpkeepPhase.StateCommitment;
@@ -728,7 +730,7 @@
             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 {
                 currentPhase = LiquidityUpkeepPhase.StateCommitment;
@@ -754,19 +756,43 @@
         }
     }
 
+    /// @notice Calculate maximum amount with slippage applied
+    /// @param estimatedAmount The estimated amount
+    /// @return The maximum amount with slippage applied
+    function _calculateMaxWithSlippage(uint256 estimatedAmount) internal view returns (uint256) {
+        return estimatedAmount.mulDiv(BASIS_POINTS_FACTOR + slippageTolerance, BASIS_POINTS_FACTOR);
+    }
+
+    /// @notice Calculate minimum amount with slippage applied
+    /// @param estimatedAmount The estimated amount
+    /// @return The minimum amount with slippage applied
+    function _calculateMinWithSlippage(uint256 estimatedAmount) internal view returns (uint256) {
+        return estimatedAmount.mulDiv(BASIS_POINTS_FACTOR - slippageTolerance, BASIS_POINTS_FACTOR);
+    }
+
     /// @notice Executes a sell order
     /// @param asset The asset to sell
     /// @param sharesAmount The amount of shares to sell
     /// @param estimatedUnderlyingAmount The estimated underlying amount to receive
-    function _executeSell(address asset, uint256 sharesAmount, uint256 estimatedUnderlyingAmount) external onlySelf {
+    function _executeSell(
+        address asset,
+        uint256 sharesAmount,
+        uint256 estimatedUnderlyingAmount
+    ) external onlySelf nonReentrant {
         IExecutionAdapter adapter = executionAdapterOf[asset];
         if (address(adapter) == address(0)) revert ErrorsLib.AdapterNotSet();
 
         // Approve adapter to spend shares
         IERC20(asset).forceApprove(address(adapter), sharesAmount);
 
         // Execute sell through adapter, pull shares from this contract and push underlying assets to it.
-        uint256 executionUnderlyingAmount = adapter.sell(asset, sharesAmount, estimatedUnderlyingAmount);
+        uint256 executionUnderlyingAmount = adapter.sell(asset, sharesAmount);
+
+        // Validate slippage of trade is within tolerance.
+        uint256 minUnderlyingAmount = _calculateMinWithSlippage(estimatedUnderlyingAmount);
+        if (executionUnderlyingAmount < minUnderlyingAmount) {
+            revert ErrorsLib.SlippageExceeded(asset, executionUnderlyingAmount, minUnderlyingAmount);
+        }
 
         // Clean up approval
         IERC20(asset).forceApprove(address(adapter), 0);
@@ -778,19 +804,20 @@
     /// @param asset The asset to buy
     /// @param sharesAmount The amount of shares to buy
     /// @param estimatedUnderlyingAmount The estimated underlying amount to spend
-    /// @dev The adapter handles slippage tolerance internally.
-    function _executeBuy(address asset, uint256 sharesAmount, uint256 estimatedUnderlyingAmount) external onlySelf {
+    function _executeBuy(
+        address asset,
+        uint256 sharesAmount,
+        uint256 estimatedUnderlyingAmount
+    ) external onlySelf nonReentrant {
         IExecutionAdapter adapter = executionAdapterOf[asset];
         if (address(adapter) == address(0)) revert ErrorsLib.AdapterNotSet();
 
-        // Approve adapter to spend underlying assets
-        IERC20(underlyingAsset).forceApprove(
-            address(adapter),
-            estimatedUnderlyingAmount.mulDiv(BASIS_POINTS_FACTOR + slippageTolerance, BASIS_POINTS_FACTOR)
-        );
+        // Approve adapter to spend underlying assets with slippage tolerance.
+        // Slippage tolerance is enforced indirectly by capping the approval amount.
+        IERC20(underlyingAsset).forceApprove(address(adapter), _calculateMaxWithSlippage(estimatedUnderlyingAmount));
 
         // Execute buy through adapter, pull underlying assets from this contract and push shares to it.
-        uint256 executionUnderlyingAmount = adapter.buy(asset, sharesAmount, estimatedUnderlyingAmount);
+        uint256 executionUnderlyingAmount = adapter.buy(asset, sharesAmount);
 
         // Clean up approval
         IERC20(underlyingAsset).forceApprove(address(adapter), 0);

contracts/execution/ERC4626ExecutionAdapter.sol

@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.28;
+
+import { IExecutionAdapter } from "../interfaces/IExecutionAdapter.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import { IERC4626 } from "@openzeppelin/contracts/interfaces/IERC4626.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { ErrorsLib } from "../libraries/ErrorsLib.sol";
+import { IOrionConfig } from "../interfaces/IOrionConfig.sol";
+import { ILiquidityOrchestrator } from "../interfaces/ILiquidityOrchestrator.sol";
+
+/**
+ * @title ERC4626ExecutionAdapter
+ * @notice Execution adapter for ERC-4626 vaults with generic underlying asset.
+ * @author Orion Finance
+ * @dev Architecture:
+ * - Handles same-asset flows: protocolUnderlying=vaultUnderlying → vaultShares
+ * - Handles cross-asset flows: protocolUnderlying → ExecutionAdapter → vaultUnderlying → vaultShares
+ *
+ * @custom:security-contact security@orionfinance.ai
+ */
+contract ERC4626ExecutionAdapter is IExecutionAdapter {
+    using SafeERC20 for IERC20;
+
+    /// @notice Orion protocol configuration contract
+    IOrionConfig public immutable CONFIG;
+
+    /// @notice Protocol underlying asset
+    IERC20 public immutable UNDERLYING_ASSET;
+
+    /// @notice Liquidity orchestrator contract
+    ILiquidityOrchestrator public immutable LIQUIDITY_ORCHESTRATOR;
+
+    /**
+     * @notice Constructor
+     * @param configAddress OrionConfig contract address
+     */
+    constructor(address configAddress) {
+        if (configAddress == address(0)) revert ErrorsLib.ZeroAddress();
+
+        CONFIG = IOrionConfig(configAddress);
+        UNDERLYING_ASSET = IERC20(CONFIG.underlyingAsset());
+        LIQUIDITY_ORCHESTRATOR = ILiquidityOrchestrator(CONFIG.liquidityOrchestrator());
+
+        if (address(LIQUIDITY_ORCHESTRATOR) == address(0)) revert ErrorsLib.ZeroAddress();
+    }
+
+    /// @notice Internal validation function that performs compatibility checks
+    /// @param asset The address of the asset to validate
+    function _validateExecutionAdapter(address asset) internal view {
+        // 1. Verify asset implements IERC4626
+        try IERC4626(asset).asset() returns (address vaultUnderlying) {
+            // 2. Verify registered vault decimals match config decimals
+            try IERC20Metadata(asset).decimals() returns (uint8 vaultDecimals) {
+                if (vaultDecimals != CONFIG.getTokenDecimals(asset)) {
+                    revert ErrorsLib.InvalidAdapter(asset);
+                }
+            } catch {
+                revert ErrorsLib.InvalidAdapter(asset);
+            }
+
+            // 3. Verify underlying vault decimals match config decimals
+            // (vault underlying must be whitelisted in config)
+            try IERC20Metadata(vaultUnderlying).decimals() returns (uint8 vaultUnderlyingDecimals) {
+                if (vaultUnderlyingDecimals != CONFIG.getTokenDecimals(vaultUnderlying)) {
+                    revert ErrorsLib.InvalidAdapter(asset);
+                }
+            } catch {
+                revert ErrorsLib.InvalidAdapter(asset);
+            }
+        } catch {
+            revert ErrorsLib.InvalidAdapter(asset);
+        }
+    }
+
+    /// @inheritdoc IExecutionAdapter
+    function validateExecutionAdapter(address asset) external view override {
+        _validateExecutionAdapter(asset);
+    }
+
+    /// @inheritdoc IExecutionAdapter
+    function previewBuy(address vaultAsset, uint256 sharesAmount) external returns (uint256 underlyingAmount) {
+        IERC4626 vault = IERC4626(vaultAsset);
+        address vaultUnderlying = vault.asset();
+        uint256 vaultUnderlyingNeeded = vault.previewMint(sharesAmount);
+
+        if (vaultUnderlying == address(UNDERLYING_ASSET)) {
+            return vaultUnderlyingNeeded;
+        }
+        IExecutionAdapter swapExecutor = IExecutionAdapter(
+            address(LIQUIDITY_ORCHESTRATOR.executionAdapterOf(vaultUnderlying))
+        );
+        return swapExecutor.previewBuy(vaultUnderlying, vaultUnderlyingNeeded);
+    }
+
+    /// @inheritdoc IExecutionAdapter
+    function sell(
+        address vaultAsset,
+        uint256 sharesAmount
+    ) external override returns (uint256 receivedUnderlyingAmount) {
+        if (sharesAmount == 0) revert ErrorsLib.AmountMustBeGreaterThanZero(vaultAsset);
+        // Atomically validate order generation assumptions
+        _validateExecutionAdapter(vaultAsset);
+
+        IERC4626 vault = IERC4626(vaultAsset);
+        address vaultUnderlying = vault.asset();
+
+        if (vaultUnderlying == address(UNDERLYING_ASSET)) {
+            receivedUnderlyingAmount = vault.redeem(sharesAmount, msg.sender, msg.sender);
+        } else {
+            uint256 receivedVaultUnderlyingAmount = vault.redeem(sharesAmount, address(this), msg.sender);
+
+            IExecutionAdapter swapExecutor = IExecutionAdapter(
+                address(LIQUIDITY_ORCHESTRATOR.executionAdapterOf(vaultUnderlying))
+            );
+
+            IERC20(vaultUnderlying).forceApprove(address(swapExecutor), receivedVaultUnderlyingAmount);
+
+            receivedUnderlyingAmount = swapExecutor.sell(vaultUnderlying, receivedVaultUnderlyingAmount);
+
+            // Clean up approval
+            IERC20(vaultUnderlying).forceApprove(address(swapExecutor), 0);
+
+            UNDERLYING_ASSET.safeTransfer(msg.sender, receivedUnderlyingAmount);
+        }
+    }
+
+    /// @inheritdoc IExecutionAdapter
+    function buy(address vaultAsset, uint256 sharesAmount) external override returns (uint256 spentUnderlyingAmount) {
+        if (sharesAmount == 0) revert ErrorsLib.AmountMustBeGreaterThanZero(vaultAsset);
+        _validateExecutionAdapter(vaultAsset);
+
+        IERC4626 vault = IERC4626(vaultAsset);
+        address vaultUnderlying = vault.asset();
+        uint256 vaultUnderlyingNeeded = vault.previewMint(sharesAmount);
+
+        uint256 underlyingNeeded;
+        if (vaultUnderlying == address(UNDERLYING_ASSET)) {
+            underlyingNeeded = vaultUnderlyingNeeded;
+        } else {
+            underlyingNeeded = this.previewBuy(vaultAsset, sharesAmount);
+        }
+
+        // Pull previewed amount from the caller.
+        UNDERLYING_ASSET.safeTransferFrom(msg.sender, address(this), underlyingNeeded);
+
+        if (vaultUnderlying == address(UNDERLYING_ASSET)) {
+            // Approve vault to spend underlying assets
+            UNDERLYING_ASSET.forceApprove(vaultAsset, underlyingNeeded);
+
+            // Mint exact shares. Vault will pull the required underlying amount
+            // This guarantees sharesAmount shares are minted.
+            spentUnderlyingAmount = vault.mint(sharesAmount, address(this));
+            // Some ERC4626 implementations may leave dust in the adapter;
+            // we accept that, as target shares are minted.
+
+            // Clean up approval
+            UNDERLYING_ASSET.forceApprove(vaultAsset, 0);
+        } else {
+            IExecutionAdapter swapExecutor = IExecutionAdapter(
+                address(LIQUIDITY_ORCHESTRATOR.executionAdapterOf(vaultUnderlying))
+            );
+            // Approve swap executor to spend underlying assets
+            UNDERLYING_ASSET.forceApprove(address(swapExecutor), underlyingNeeded);
+
+            spentUnderlyingAmount = swapExecutor.buy(vaultUnderlying, vaultUnderlyingNeeded);
+            // Swap Executor may leave dust in the adapter, we accept that.
+
+            // Clean up approval
+            UNDERLYING_ASSET.forceApprove(address(swapExecutor), 0);
+
+            // Approve vault to spend vault underlying assets
+            IERC20(vaultUnderlying).forceApprove(vaultAsset, vaultUnderlyingNeeded);
+
+            // Mint exact shares. Vault will pull the required underlying amount
+            // This guarantees sharesAmount shares are minted.
+            // slither-disable-next-line unused-return
+            vault.mint(sharesAmount, address(this));
+            // Some ERC4626 implementations may leave dust in the adapter;
+            // we accept that, as target shares are minted.
+
+            // Clean up approval
+            IERC20(vaultUnderlying).forceApprove(vaultAsset, 0);
+        }
+
+        // Push all minted shares to the caller (LO)
+        IERC20(vaultAsset).safeTransfer(msg.sender, sharesAmount);
+    }
+}