feat: pollFunds for just-in-time order funding

anxolin · anxolin · commit d07ce515ab62 · 2026-07-13T12:15:46.000+03:00
diff --git a/src/types/ComposableCowPoller.sol b/src/types/ComposableCowPoller.sol
@@ -1,10 +1,15 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity >=0.8.0 <0.9.0;
 
-import {IConditionalOrderGenerator} from "../interfaces/IConditionalOrder.sol";
+import {IERC20, GPv2Order} from "cowprotocol/contracts/libraries/GPv2Order.sol";
+
+import {ComposableCoW} from "../ComposableCoW.sol";
+import {IConditionalOrder, IConditionalOrderGenerator} from "../interfaces/IConditionalOrder.sol";
 
 /// @title ComposableCowPoller - Just-in-time funding for composable conditional orders.
 contract ComposableCowPoller {
+    ComposableCoW public immutable composableCow;
+
     struct Schedule {
         IConditionalOrderGenerator handler; // the conditional-order handler to poll (e.g. the TWAP type)
         address funder; // source of funds; the only registrant
@@ -17,9 +22,19 @@ contract ComposableCowPoller {
     ///      order's `appData`.
     mapping(bytes32 => Schedule) public schedules;
 
+    /// @dev `id => digest` of the order last funded, so each order is funded at most once.
+    mapping(bytes32 => bytes32) public lastFunded;
+
     error OnlyFunder();
+    error NoSchedule();
+    error OrderNotLive();
 
     event ScheduleRegistered(bytes32 indexed id, address indexed owner, address indexed funder);
+    event Pulled(bytes32 indexed id, bytes32 orderDigest, uint256 amount);
+
+    constructor(ComposableCoW _composableCow) {
+        composableCow = _composableCow;
+    }
 
     /// @notice Deterministic, appData-independent schedule key.
     function scheduleId(address funder, IConditionalOrderGenerator handler, address owner, bytes32 salt)
@@ -36,6 +51,39 @@ contract ComposableCowPoller {
         if (msg.sender != schedule.funder) revert OnlyFunder();
         id = scheduleId(schedule.funder, schedule.handler, schedule.owner, schedule.salt);
         schedules[id] = schedule;
+        delete lastFunded[id]; // reset funding history
         emit ScheduleRegistered(id, schedule.owner, schedule.funder);
     }
+
+    /// @notice Move the current order's `sellAmount` from the funder to the owner. Permissionless.
+    ///         The full amount always moves (no balance check), so one owner can serve several
+    ///         concurrent orders.
+    function pollFunds(bytes32 id) external {
+        Schedule memory schedule = schedules[id];
+        if (schedule.funder == address(0)) revert NoSchedule();
+
+        // Re-derive `ctx` on-chain, so `pollFunds(id)` stays independent of the order's `appData`.
+        bytes32 ctx = composableCow.hash(
+            IConditionalOrder.ConditionalOrderParams({
+                handler: schedule.handler,
+                salt: schedule.salt,
+                staticInput: schedule.staticInput
+            })
+        );
+
+        // The order must still be authorised; `remove` disables the poller.
+        if (!composableCow.singleOrders(schedule.owner, ctx)) revert OrderNotLive();
+
+        // The handler yields the current order and reverts outside its window.
+        GPv2Order.Data memory order =
+            schedule.handler.getTradeableOrder(schedule.owner, address(this), ctx, schedule.staticInput, bytes(""));
+
+        // Fund each order at most once.
+        bytes32 digest = GPv2Order.hash(order, composableCow.domainSeparator());
+        if (digest == lastFunded[id]) return;
+        lastFunded[id] = digest;
+
+        order.sellToken.transferFrom(schedule.funder, schedule.owner, order.sellAmount);
+        emit Pulled(id, digest, order.sellAmount);
+    }
 }
diff --git a/test/ComposableCowPoller.t.sol b/test/ComposableCowPoller.t.sol
@@ -28,7 +28,7 @@ contract ComposableCowPollerTest is BaseComposableCoWTest {
 
         twap = new TWAP(composableCow);
         currentBlockTimestampFactory = new CurrentBlockTimestampFactory();
-        poller = new ComposableCowPoller();
+        poller = new ComposableCowPoller(composableCow);
         funder = makeAddr("funder");
 
         // The owner (safe1) starts with no sell token: funds arrive just-in-time.
@@ -54,7 +54,7 @@ contract ComposableCowPollerTest is BaseComposableCoWTest {
     /// @dev Creates a JIT-funded TWAP: order via context, the funder funds + approves the poller,
     ///      and the schedule is registered. Returns the order's cabinet key `ctx`
     ///      (`ComposableCoW.hash(params)`, used for cabinet/remove) and the appData-independent
-    ///      poller schedule key `id` (used for topUp/revoke).
+    ///      poller schedule key `id` (used for pollFunds/revoke).
     function _setupSchedule()
         internal
         returns (
@@ -105,6 +105,12 @@ contract ComposableCowPollerTest is BaseComposableCoWTest {
         );
     }
 
+    /// @dev The order's resolved start time `t0`, read back from the cabinet where
+    ///      `createWithContext` stored it via `CurrentBlockTimestampFactory`.
+    function _t0(bytes32 ctx) internal view returns (uint256) {
+        return uint256(composableCow.cabinet(address(safe1), ctx));
+    }
+
     /// @dev A registered schedule is stored under its appData-independent id.
     function test_register_storesSchedule() public {
         (, , bytes32 id) = _setupSchedule();
@@ -130,4 +136,158 @@ contract ComposableCowPollerTest is BaseComposableCoWTest {
             })
         );
     }
+
+    /// @dev A single poll moves exactly the current part into the owner.
+    function test_pollFunds_fundsCurrentPart() public {
+        (, bytes32 ctx, bytes32 id) = _setupSchedule();
+        vm.warp(_t0(ctx));
+
+        assertEq(
+            token0.balanceOf(address(safe1)),
+            0,
+            "owner empty before pull"
+        );
+
+        poller.pollFunds(id);
+
+        assertEq(
+            token0.balanceOf(address(safe1)),
+            PART,
+            "owner funded with exactly one part"
+        );
+        assertEq(
+            token0.balanceOf(funder),
+            PART * N - PART,
+            "exactly one part left the funder"
+        );
+    }
+
+    /// @dev Funds move unconditionally: even if the owner already holds a balance (e.g. from another
+    ///      concurrent order), the full part is still pulled, so orders never share funding.
+    function test_pollFunds_movesFullAmountUnconditionally() public {
+        (, bytes32 ctx, bytes32 id) = _setupSchedule();
+        vm.warp(_t0(ctx));
+
+        // The owner already holds an unrelated balance (e.g. funded for another order).
+        deal(address(token0), address(safe1), PART);
+
+        poller.pollFunds(id);
+
+        assertEq(
+            token0.balanceOf(address(safe1)),
+            PART * 2,
+            "full part pulled on top of the existing balance"
+        );
+        assertEq(
+            token0.balanceOf(funder),
+            PART * N - PART,
+            "a full part left the funder"
+        );
+    }
+
+    /// @dev Repeated calls for the same part are a no-op (guarded by the order digest).
+    function test_pollFunds_idempotentWithinPart() public {
+        (, bytes32 ctx, bytes32 id) = _setupSchedule();
+        vm.warp(_t0(ctx));
+
+        poller.pollFunds(id);
+        poller.pollFunds(id); // no-op: this part has already been funded
+
+        assertEq(
+            token0.balanceOf(address(safe1)),
+            PART,
+            "still exactly one part"
+        );
+        assertEq(token0.balanceOf(funder), PART * N - PART, "no extra pull");
+    }
+
+    /// @dev The headline flow: each part is funded JIT and the owner holds nothing in between.
+    function test_pollFunds_fundsEachPartAcrossSchedule() public {
+        (, bytes32 ctx, bytes32 id) = _setupSchedule();
+        uint256 t0 = _t0(ctx);
+
+        for (uint256 part = 0; part < N; part++) {
+            vm.warp(t0 + part * FREQ);
+
+            assertEq(
+                token0.balanceOf(address(safe1)),
+                0,
+                "owner empty before part"
+            );
+            poller.pollFunds(id);
+            assertEq(token0.balanceOf(address(safe1)), PART, "part funded");
+
+            // Simulate the part settling: the owner's balance is consumed.
+            vm.prank(address(safe1));
+            token0.transfer(bob.addr, PART);
+
+            assertEq(
+                token0.balanceOf(funder),
+                PART * N - PART * (part + 1),
+                "one part funded per window"
+            );
+        }
+    }
+
+    /// @dev The anti-premature-execution guard: once a part is funded, the *next* part's funds
+    ///      cannot be pulled until time advances into its window — even after the part settles and
+    ///      drains the owner. Without the per-order guard, the drained owner would be refilled
+    ///      immediately and that balance would be sold as the next part, a full interval early.
+    function test_pollFunds_cannotFundFuturePartEarly() public {
+        (, bytes32 ctx, bytes32 id) = _setupSchedule();
+        vm.warp(_t0(ctx)); // part 0 window
+
+        poller.pollFunds(id);
+        assertEq(token0.balanceOf(address(safe1)), PART, "part 0 funded");
+
+        // Simulate the part settling: the owner's balance is consumed.
+        vm.prank(address(safe1));
+        token0.transfer(bob.addr, PART);
+        assertEq(
+            token0.balanceOf(address(safe1)),
+            0,
+            "owner drained by the fill"
+        );
+
+        // Still inside part 0's window: a fresh pull must NOT refill.
+        poller.pollFunds(id);
+
+        assertEq(
+            token0.balanceOf(address(safe1)),
+            0,
+            "next part not funded early"
+        );
+        assertEq(
+            token0.balanceOf(funder),
+            PART * N - PART,
+            "exactly one part ever left the funder"
+        );
+    }
+
+    /// @dev The pull is bounded to the schedule window: after it ends, `getTradeableOrder` reverts.
+    function test_pollFunds_RevertWhen_scheduleEnded() public {
+        (, bytes32 ctx, bytes32 id) = _setupSchedule();
+        vm.warp(_t0(ctx) + N * FREQ);
+
+        vm.expectRevert(); // IConditionalOrder.OrderNotValid(...) from the handler
+        poller.pollFunds(id);
+    }
+
+    /// @dev An unregistered schedule cannot be polled.
+    function test_pollFunds_RevertWhen_noSchedule() public {
+        vm.expectRevert(ComposableCowPoller.NoSchedule.selector);
+        poller.pollFunds(keccak256("unknown"));
+    }
+
+    /// @dev Cancelling the order flips `singleOrders` false, which disables the poller for free.
+    function test_remove_killsPoller() public {
+        (, bytes32 ctx, bytes32 id) = _setupSchedule();
+        vm.warp(_t0(ctx));
+
+        vm.prank(address(safe1));
+        composableCow.remove(ctx);
+
+        vm.expectRevert(ComposableCowPoller.OrderNotLive.selector);
+        poller.pollFunds(id);
+    }
 }
