@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.22;
+
+import {MarketParams} from "lib/morpho-blue/src/interfaces/IMorpho.sol";
+
+/// @title IMorphoAllocator
+/// @author 3F Protocol
+/// @notice Local minimal interface for the externally-deployed MorphoAllocator facilitator.
+/// @dev The canonical contract lives in the facilitators repo; grunt does not depend on it, so only the
+///      `run` entrypoint and its `Deallocation` struct are mirrored here. The encoding is ABI-compatible
+///      because grunt's `MarketParams` is structurally identical to the facilitators copy. Keep this
+///      signature in sync with the deployed MorphoAllocator.
+interface IMorphoAllocator {
+  /// @notice A single source from which `run` gathers liquidity before allocating the total.
+  /// @param adapter Morpho V1 Market adapter to deallocate from, or address(0) for idle liquidity.
+  /// @param marketParams Source market identifier, ignored when adapter is address(0).
+  /// @param amount Assets to source from this entry; contributes to the allocated total.
+  /// @param maxUtilisation Post-deallocation utilisation cap in WAD, ignored when adapter is address(0).
+  struct Deallocation {
+    address adapter;
+    MarketParams marketParams;
+    uint256 amount;
+    uint256 maxUtilisation;
+  }
+
+  /// @notice Unlocks a matured fund DEPOSIT order, rebalances Morpho Vault V2 liquidity, then runs
+  ///         depositManager and borrows.
+  /// @param intentId The intent ID.
+  /// @param deallocations Sources to gather liquidity from (markets and/or idle); see {Deallocation}.
+  /// @param allocateAdapter Destination Morpho V1 Market adapter, or address(0) to skip allocation.
+  /// @param allocateMarket Destination market, ignored when allocateAdapter is address(0).
+  /// @param depositAmount Collateral amount to deposit via depositManager (caller's fixed choice).
+  /// @param borrowAmount The amount to borrow via depositManager.
+  /// @param useTarget Whether to use the target asset for the position manager deposit.
+  /// @param minSharesUnlocked The minimum amount that must be unlocked (slippage guard on unlock).
+  function run(
+    uint256 intentId,
+    Deallocation[] calldata deallocations,
+    address allocateAdapter,
+    MarketParams calldata allocateMarket,
+    uint256 depositAmount,
+    uint256 borrowAmount,
+    bool useTarget,
+    uint256 minSharesUnlocked
+  ) external;
+}
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.24;
+
+import {IFacilityFunds} from "../../interfaces/facility/base/IFacilityFunds.sol";
+import {IMorphoAllocator} from "../../interfaces/request/IMorphoAllocator.sol";
+import {Mode} from "../../libs/funds/Order.sol";
+import {MarketParams} from "lib/morpho-blue/src/interfaces/IMorpho.sol";
+
+/// @title SyncAllocatorDeposit
+/// @notice Stateless script designed to be delegatecalled from MorphoFlashLoanRequest.
+///         Executes a synchronous deposit flow: create → commit → allocator.run, delegating the
+///         unlock, Morpho Vault V2 rebalancing, and depositManager steps to the MorphoAllocator.
+/// @dev Must NOT have any storage variables. The fund must be set on the intent before execute().
+///      Runs under delegatecall, so allocator.run executes with msg.sender == MorphoFlashLoanRequest,
+///      which must hold EXECUTOR_ROLE on the allocator; the allocator must hold FACILITATOR_ROLE on the
+///      facility and be a whitelisted allocator on the Vault V2.
+/// @author 3F Protocol
+contract SyncAllocatorDeposit {
+  /// @notice Parameters forwarded to IMorphoAllocator.run, grouped into a struct to keep run() under
+  ///         the ABI decoder stack limit (the project compiles without via-ir).
+  /// @param deallocations Vault V2 liquidity sources to gather before allocating; see IMorphoAllocator.
+  /// @param allocateAdapter Destination Morpho V1 Market adapter, or address(0) to skip allocation.
+  /// @param allocateMarket Destination market, ignored when allocateAdapter is address(0).
+  /// @param depositAmount Collateral amount to deposit via depositManager (caller's fixed choice).
+  /// @param borrowAmount The amount to borrow via the position manager.
+  /// @param useTarget Whether to use the target asset for the position manager deposit.
+  /// @param minSharesUnlocked The minimum amount that must be unlocked (allocator unlock slippage guard).
+  struct AllocatorParams {
+    IMorphoAllocator.Deallocation[] deallocations;
+    address allocateAdapter;
+    MarketParams allocateMarket;
+    uint256 depositAmount;
+    uint256 borrowAmount;
+    bool useTarget;
+    uint256 minSharesUnlocked;
+  }
+
+  /// @notice Executes the synchronous allocator-backed deposit flow for a facility intent.
+  /// @param facility The facility contract address.
+  /// @param allocator The deployed MorphoAllocator to delegate unlock and depositManager to.
+  /// @param intentId The intent ID on the facility.
+  /// @param fundDepositAmount The amount to deposit into the fund order.
+  /// @param minSharesOut The minimum shares expected from the deposit.
+  /// @param params The parameters forwarded to IMorphoAllocator.run.
+  function run(
+    address facility,
+    address allocator,
+    uint256 intentId,
+    uint256 fundDepositAmount,
+    uint256 minSharesOut,
+    AllocatorParams calldata params
+  ) external {
+    // 1. Create deposit order on fund
+    IFacilityFunds(facility).create(intentId, fundDepositAmount, minSharesOut, Mode.DEPOSIT);
+
+    // 2. Commit order (facility sends tokens to fund)
+    IFacilityFunds(facility).commit(intentId);
+
+    // 3. Delegate unlock, vault rebalance, and depositManager to the allocator
+    IMorphoAllocator(allocator)
+      .run(
+        intentId,
+        params.deallocations,
+        params.allocateAdapter,
+        params.allocateMarket,
+        params.depositAmount,
+        params.borrowAmount,
+        params.useTarget,
+        params.minSharesUnlocked
+      );
+  }
+}
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.24;
+
+import {IMorphoAllocator} from "../../../src/interfaces/request/IMorphoAllocator.sol";
+import {IFacilityFunds} from "../../../src/interfaces/facility/base/IFacilityFunds.sol";
+import {IFacilityPositionManager} from "../../../src/interfaces/facility/base/IFacilityPositionManager.sol";
+import {MarketParams} from "lib/morpho-blue/src/interfaces/IMorpho.sol";
+import {OwnableRoles} from "lib/solady/src/auth/OwnableRoles.sol";
+
+/// @notice Test double for the externally-deployed MorphoAllocator. Implements IMorphoAllocator,
+///         enforces EXECUTOR_ROLE, and mirrors the facility side of the real `run` (unlock +
+///         depositManager). Vault V2 rebalancing is not modeled (grunt has no Vault V2 mocks); the
+///         rebalance params are recorded instead so tests can assert the script routed them through.
+contract MockMorphoAllocator is IMorphoAllocator, OwnableRoles {
+  uint256 internal constant EXECUTOR_ROLE = _ROLE_0;
+
+  address public immutable facility;
+
+  uint256 public lastDeallocationsLength;
+  address public lastAllocateAdapter;
+  uint256 public lastDepositAmount;
+  uint256 public lastBorrowAmount;
+  bool public lastUseTarget;
+  uint256 public lastMinSharesUnlocked;
+
+  constructor(address owner_, address facility_) {
+    _initializeOwner(owner_);
+    facility = facility_;
+  }
+
+  function run(
+    uint256 intentId,
+    Deallocation[] calldata deallocations,
+    address allocateAdapter,
+    MarketParams calldata, // allocateMarket — vault rebalancing not modeled in grunt
+    uint256 depositAmount,
+    uint256 borrowAmount,
+    bool useTarget,
+    uint256 minSharesUnlocked
+  ) external onlyRoles(EXECUTOR_ROLE) {
+    lastDeallocationsLength = deallocations.length;
+    lastAllocateAdapter = allocateAdapter;
+    lastDepositAmount = depositAmount;
+    lastBorrowAmount = borrowAmount;
+    lastUseTarget = useTarget;
+    lastMinSharesUnlocked = minSharesUnlocked;
+
+    // Mirror the real allocator: unlock the matured order, then deposit + borrow via the PM.
+    IFacilityFunds(facility).unlock(intentId);
+    IFacilityPositionManager(facility).depositManager(intentId, depositAmount, borrowAmount, useTarget);
+  }
+}
@@ -6,12 +6,16 @@ import {MorphoFlashLoanRequest} from "src/request/MorphoFlashLoanRequest.sol";
 import {MorphoFlashLoanRequestFactory} from "src/request/MorphoFlashLoanRequestFactory.sol";
 import {SyncDeposit} from "src/request/scripts/SyncDeposit.sol";
 import {SyncWithdrawal} from "src/request/scripts/SyncWithdrawal.sol";
+import {SyncAllocatorDeposit} from "src/request/scripts/SyncAllocatorDeposit.sol";
+import {IMorphoAllocator} from "src/interfaces/request/IMorphoAllocator.sol";
+import {MockMorphoAllocator} from "test/mock/request/MockMorphoAllocator.sol";
 import {Offer} from "src/interfaces/request/IOfferReceiver.sol";
 import {LibCommonErrors} from "src/libs/common/LibCommonErrors.sol";
 import {MockERC20} from "test/mock/MockERC20.sol";
 import {Mode, State} from "src/libs/funds/Order.sol";
 import {IntentProperties, Asset} from "src/libs/facility/LibIntent.sol";
 import {WithdrawalStrategy} from "src/interfaces/manager/base/IPositionManagerAdmin.sol";
+import {MarketParams} from "lib/morpho-blue/src/interfaces/IMorpho.sol";
 
 /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
 /*                      HELPER CONTRACTS                         */
@@ -102,6 +106,8 @@ contract MorphoFlashLoanRequestTest is FacilityBaseTest {
   MockScript public mockScript;
   SyncDeposit public syncDeposit;
   SyncWithdrawal public syncWithdrawal;
+  SyncAllocatorDeposit public syncAllocatorDeposit;
+  MockMorphoAllocator public mockAllocator;
 
   address public executor = makeAddr("executor");
 
@@ -141,6 +147,22 @@ contract MorphoFlashLoanRequestTest is FacilityBaseTest {
     vm.prank(owner);
     flashLoanRequest.setScript(address(syncWithdrawal), true);
 
+    // Deploy and whitelist SyncAllocatorDeposit
+    syncAllocatorDeposit = new SyncAllocatorDeposit();
+    vm.label(address(syncAllocatorDeposit), "SyncAllocatorDeposit");
+    vm.prank(owner);
+    flashLoanRequest.setScript(address(syncAllocatorDeposit), true);
+
+    // Deploy a MorphoAllocator test double and wire its roles:
+    // - it holds FACILITATOR_ROLE on the facility (to unlock + depositManager)
+    // - the flash loan request proxy holds EXECUTOR_ROLE on it (msg.sender under delegatecall)
+    mockAllocator = new MockMorphoAllocator(owner, address(facility));
+    vm.label(address(mockAllocator), "MockMorphoAllocator");
+    vm.prank(owner);
+    facility.grantRoles(address(mockAllocator), FACILITATOR_ROLE);
+    vm.prank(owner);
+    mockAllocator.grantRoles(address(flashLoanRequest), 1); // EXECUTOR_ROLE == _ROLE_0
+
     // Create an intent with deposits and move to resolving phase
     intentId = _createIntentWithDeposits(DEFAULT_AMOUNT);
   }
@@ -605,6 +627,174 @@ contract MorphoFlashLoanRequestTest is FacilityBaseTest {
     assertEq(collateralToken.balanceOf(address(facility)), 0);
   }
 
+  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+  /*       H1b. SYNC ALLOCATOR DEPOSIT INTEGRATION TEST           */
+  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+  /// @dev Sets up a fresh targetPM intent in the resolving phase with the mock fund configured for a
+  ///      synchronous deposit (create → ACCEPTED, commit → UNLOCKING, unlock → ENDED). Returns the
+  ///      intent ID and the amount used for the fund deposit / shares / borrow.
+  function _setupSyncAllocatorIntent() internal returns (uint256 syncIntentId, uint256 amount) {
+    vm.prank(owner);
+    syncIntentId = facility.createIntent(_intentParamsWithTargetPM());
+
+    amount = 1_000e18;
+    _mintDebt(user, amount);
+    vm.prank(user);
+    facility.deposit(syncIntentId, amount);
+
+    // Move to resolving phase
+    vm.warp(block.timestamp + 1 days + 1);
+
+    // Set the mock fund on the intent (requires facilitator + guardian sig)
+    vm.prank(facilitator);
+    _setFund(syncIntentId, address(mockFund));
+
+    mockFund.setNextCreateState(State.ACCEPTED);
+    mockFund.setNextCommitState(State.UNLOCKING);
+    mockFund.setNextUnlockState(State.ENDED);
+    mockFund.setCommitAmount(amount);
+
+    // sharesFromFund == amount so the PM deposit nets to zero shares on the facility.
+    mockFund.setUnlockAmount(amount);
+    collateralToken.setBalance(address(mockFund), amount);
+  }
+
+  function _emptyMarket() internal pure returns (MarketParams memory) {
+    return MarketParams(address(0), address(0), address(0), address(0), 0);
+  }
+
+  /// @dev Default empty-rebalance SyncAllocatorDeposit payload (deposit == borrow == amount, targetPM).
+  function _syncAllocatorDepositPayload(uint256 _intentId, uint256 amount) internal view returns (bytes memory) {
+    SyncAllocatorDeposit.AllocatorParams memory allocatorParams = SyncAllocatorDeposit.AllocatorParams({
+      deallocations: new IMorphoAllocator.Deallocation[](0),
+      allocateAdapter: address(0),
+      allocateMarket: _emptyMarket(),
+      depositAmount: amount,
+      borrowAmount: amount,
+      useTarget: true,
+      minSharesUnlocked: 0
+    });
+    return abi.encodeCall(
+      SyncAllocatorDeposit.run, (address(facility), address(mockAllocator), _intentId, amount, amount, allocatorParams)
+    );
+  }
+
+  function test_execute_syncAllocatorDepositFullCycle() public {
+    (uint256 syncIntentId, uint256 amount) = _setupSyncAllocatorIntent();
+
+    MorphoFlashLoanRequest.SetRequestParams memory params =
+      _buildSetRequestParams(syncIntentId, block.timestamp + 1 hours);
+
+    // Empty rebalance: no deallocations, allocation skipped (allocateAdapter == address(0)).
+    // pmDepositAmount = borrowAmount = amount.
+    SyncAllocatorDeposit.AllocatorParams memory allocatorParams = SyncAllocatorDeposit.AllocatorParams({
+      deallocations: new IMorphoAllocator.Deallocation[](0),
+      allocateAdapter: address(0),
+      allocateMarket: _emptyMarket(),
+      depositAmount: amount,
+      borrowAmount: amount,
+      useTarget: true, // targetPM
+      minSharesUnlocked: 0
+    });
+
+    bytes memory scriptPayload = abi.encodeCall(
+      SyncAllocatorDeposit.run,
+      (address(facility), address(mockAllocator), syncIntentId, amount, amount, allocatorParams)
+    );
+
+    uint256 morphoBalBefore = debtToken.balanceOf(address(morpho));
+
+    vm.prank(executor);
+    flashLoanRequest.execute(amount, params, address(syncAllocatorDeposit), scriptPayload);
+
+    // Verify: request removed from intent
+    (,, address request,) = facility.getIntent(syncIntentId);
+    assertEq(request, address(0));
+
+    // Verify: flash loan fully repaid (Morpho balance only decreased by borrow amount, not flash loan)
+    assertEq(debtToken.balanceOf(address(morpho)), morphoBalBefore - amount);
+
+    // Verify: flash loan request has no leftover balance
+    assertEq(debtToken.balanceOf(address(flashLoanRequest)), 0);
+
+    // Verify: collateral was deposited into PM (facility no longer holds it)
+    assertEq(collateralToken.balanceOf(address(facility)), 0);
+
+    // Verify: the allocator received the params routed by the script
+    assertEq(mockAllocator.lastDepositAmount(), amount);
+    assertEq(mockAllocator.lastBorrowAmount(), amount);
+    assertEq(mockAllocator.lastDeallocationsLength(), 0);
+    assertEq(mockAllocator.lastAllocateAdapter(), address(0));
+    assertTrue(mockAllocator.lastUseTarget());
+  }
+
+  function test_execute_syncAllocatorDeposit_forwardsDeallocations() public {
+    (uint256 syncIntentId, uint256 amount) = _setupSyncAllocatorIntent();
+
+    MorphoFlashLoanRequest.SetRequestParams memory params =
+      _buildSetRequestParams(syncIntentId, block.timestamp + 1 hours);
+
+    // Non-empty rebalance: proves the calldata array survives delegatecall + encode/decode round-trip.
+    IMorphoAllocator.Deallocation[] memory deallocations = new IMorphoAllocator.Deallocation[](1);
+    deallocations[0] = IMorphoAllocator.Deallocation({
+      adapter: address(0xADA9), marketParams: _emptyMarket(), amount: 123, maxUtilisation: 1e18
+    });
+
+    SyncAllocatorDeposit.AllocatorParams memory allocatorParams = SyncAllocatorDeposit.AllocatorParams({
+      deallocations: deallocations,
+      allocateAdapter: address(0xBEEF),
+      allocateMarket: _emptyMarket(),
+      depositAmount: amount,
+      borrowAmount: amount,
+      useTarget: true,
+      minSharesUnlocked: 0
+    });
+
+    bytes memory scriptPayload = abi.encodeCall(
+      SyncAllocatorDeposit.run,
+      (address(facility), address(mockAllocator), syncIntentId, amount, amount, allocatorParams)
+    );
+
+    vm.prank(executor);
+    flashLoanRequest.execute(amount, params, address(syncAllocatorDeposit), scriptPayload);
+
+    assertEq(mockAllocator.lastDeallocationsLength(), 1);
+    assertEq(mockAllocator.lastAllocateAdapter(), address(0xBEEF));
+  }
+
+  function test_execute_syncAllocatorDeposit_revertsWhenRequestLacksExecutorRole() public {
+    // Remove EXECUTOR_ROLE from the request proxy on the allocator.
+    vm.prank(owner);
+    mockAllocator.revokeRoles(address(flashLoanRequest), 1);
+
+    (uint256 syncIntentId, uint256 amount) = _setupSyncAllocatorIntent();
+
+    MorphoFlashLoanRequest.SetRequestParams memory params =
+      _buildSetRequestParams(syncIntentId, block.timestamp + 1 hours);
+    bytes memory scriptPayload = _syncAllocatorDepositPayload(syncIntentId, amount);
+
+    vm.prank(executor);
+    vm.expectRevert();
+    flashLoanRequest.execute(amount, params, address(syncAllocatorDeposit), scriptPayload);
+  }
+
+  function test_execute_syncAllocatorDeposit_revertsWhenAllocatorLacksFacilitatorRole() public {
+    // Remove FACILITATOR_ROLE from the allocator on the facility (so unlock reverts).
+    vm.prank(owner);
+    facility.revokeRoles(address(mockAllocator), FACILITATOR_ROLE);
+
+    (uint256 syncIntentId, uint256 amount) = _setupSyncAllocatorIntent();
+
+    MorphoFlashLoanRequest.SetRequestParams memory params =
+      _buildSetRequestParams(syncIntentId, block.timestamp + 1 hours);
+    bytes memory scriptPayload = _syncAllocatorDepositPayload(syncIntentId, amount);
+
+    vm.prank(executor);
+    vm.expectRevert();
+    flashLoanRequest.execute(amount, params, address(syncAllocatorDeposit), scriptPayload);
+  }
+
   /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
   /*          H2. SYNC WITHDRAWAL INTEGRATION TEST                */
   /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/