feat: register a polling schedule

Author: anxolin

src/types/ComposableCowPoller.sol

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity >=0.8.0 <0.9.0;
 
+import {IConditionalOrderGenerator} from "../interfaces/IConditionalOrder.sol";
+
 /// @title ComposableCowPoller - Just-in-time funding for composable conditional orders.
 /// @notice Pulls exactly the current discrete order's `sellAmount` from a funds source into the
 ///         order owner, immediately before that order settles. Designed to be invoked from a CoW
@@ -10,4 +12,48 @@ pragma solidity >=0.8.0 <0.9.0;
 /// @dev    This is the generic "ComposableCowPoller". It is not tied to any single order type; the
 ///         handler to poll is supplied per-schedule, and the amount / sell token / validity window
 ///         are all read from that handler's own `getTradeableOrder`.
-contract ComposableCowPoller {}
+///
+///         A schedule is keyed by an `id` that is *independent of the order's `appData`*
+///         (`id = scheduleId(funder, handler, owner, salt)`). This is what makes the funding hook
+///         usable from the order's own appData: the conditional order's `ctx` contains its `appData`
+///         hash, so a hook that referenced `ctx` (or `staticInput`, or the order digest) could never
+///         be embedded in that same `appData` — it would be circular. Keying on appData-independent
+///         fields breaks the cycle.
+contract ComposableCowPoller {
+    struct Schedule {
+        IConditionalOrderGenerator handler; // the conditional-order handler to poll (e.g. the TWAP type)
+        address funder; // source of funds (the EOA in the TWAP-for-EOA flow); the only registrant
+        address owner; // order owner (cow-shed / Safe); the fixed pull destination
+        bytes32 salt; // the conditional order's `salt`; with `staticInput` this rebuilds `ctx` on-chain
+        bytes staticInput; // the order's `staticInput`, passed verbatim to `getTradeableOrder`
+    }
+
+    /// @dev Keyed by `id == scheduleId(funder, handler, owner, salt)`. Deliberately NOT keyed by
+    ///      `ctx`: `ctx` contains the order's `appData`, so a `ctx`-keyed hook could not live inside
+    ///      that same `appData`. Every field of `id` is appData-independent.
+    mapping(bytes32 => Schedule) public schedules;
+
+    error OnlyFunder();
+
+    event ScheduleRegistered(bytes32 indexed id, address indexed owner, address indexed funder);
+
+    /// @notice Deterministic, appData-independent schedule key. Integrators compute this off-chain
+    ///         to embed the funding hook in the order's appData, and it is re-derived here on `register`.
+    function scheduleId(address funder, IConditionalOrderGenerator handler, address owner, bytes32 salt)
+        public
+        pure
+        returns (bytes32)
+    {
+        return keccak256(abi.encode(funder, handler, owner, salt));
+    }
+
+    /// @notice Register or update the schedule. Only the funds source itself may register, and the
+    ///         `id` is namespaced by `funder`, so nobody can point a pull at someone else's funds or
+    ///         squat another funder's schedule. The `id` is independent of the order's `appData`.
+    function register(Schedule calldata schedule) external returns (bytes32 id) {
+        if (msg.sender != schedule.funder) revert OnlyFunder();
+        id = scheduleId(schedule.funder, schedule.handler, schedule.owner, schedule.salt);
+        schedules[id] = schedule;
+        emit ScheduleRegistered(id, schedule.owner, schedule.funder);
+    }
+}

test/ComposableCowPoller.t.sol

@@ -1,23 +1,137 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity >=0.8.0 <0.9.0;
 
-import {BaseComposableCoWTest} from "./ComposableCoW.base.t.sol";
+import {IConditionalOrder, IValueFactory, BaseComposableCoWTest} from "./ComposableCoW.base.t.sol";
 
+import {TWAP} from "../src/types/twap/TWAP.sol";
+import {TWAPOrder} from "../src/types/twap/libraries/TWAPOrder.sol";
 import {ComposableCowPoller} from "../src/types/ComposableCowPoller.sol";
+import {CurrentBlockTimestampFactory} from "../src/value_factories/CurrentBlockTimestampFactory.sol";
+import {IConditionalOrderGenerator} from "../src/interfaces/IConditionalOrder.sol";
 
 /// @title ComposableCowPoller unit tests
-/// @notice Base scaffolding for the poller. Feature-specific tests (register / revoke / topUp) are
-///         added in follow-up PRs.
+/// @notice Exercises registering a schedule for a composable TWAP created via `createWithContext`.
 contract ComposableCowPollerTest is BaseComposableCoWTest {
+    uint256 constant PART = 100e18;
+    uint256 constant LIMIT = 1e18;
+    uint256 constant N = 3;
+    uint256 constant FREQ = 1 hours;
+    bytes32 constant SALT = keccak256("twap");
+
     ComposableCowPoller poller;
+    IValueFactory currentBlockTimestampFactory;
+
+    address funder;
 
     function setUp() public virtual override(BaseComposableCoWTest) {
         super.setUp();
 
+        twap = new TWAP(composableCow);
+        currentBlockTimestampFactory = new CurrentBlockTimestampFactory();
         poller = new ComposableCowPoller();
+        funder = makeAddr("funder");
+
+        // The owner (safe1) starts with no sell token: funds arrive just-in-time.
+        deal(address(token0), address(safe1), 0);
+    }
+
+    function _bundle() internal view returns (TWAPOrder.Data memory) {
+        return
+            TWAPOrder.Data({
+                sellToken: token0,
+                buyToken: token1,
+                receiver: address(0), // the owner itself
+                partSellAmount: PART,
+                minPartLimit: LIMIT,
+                t0: 0, // resolved from the cabinet via createWithContext
+                n: N,
+                t: FREQ,
+                span: 0, // valid for the whole epoch
+                appData: keccak256("dca.pull")
+            });
+    }
+
+    /// @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).
+    function _setupSchedule()
+        internal
+        returns (
+            IConditionalOrder.ConditionalOrderParams memory params,
+            bytes32 ctx,
+            bytes32 id
+        )
+    {
+        params = super.createOrder(twap, SALT, abi.encode(_bundle()));
+        _createWithContext(
+            address(safe1),
+            params,
+            currentBlockTimestampFactory,
+            bytes(""),
+            false
+        );
+        ctx = composableCow.hash(params);
+
+        // Capital lives in the funder (the EOA), which approves the poller for the full notional.
+        deal(address(token0), funder, PART * N);
+        vm.prank(funder);
+        token0.approve(address(poller), PART * N);
+
+        // Register the schedule (only the funder may do this). The schedule carries the handler,
+        // the funds source, the destination, the order's `salt` (so the poller can rebuild `ctx`
+        // on-chain) and its `staticInput`. The key is appData-independent so the funding hook can
+        // live in the order's own appData.
+        vm.prank(funder);
+        id = poller.register(
+            ComposableCowPoller.Schedule({
+                handler: IConditionalOrderGenerator(address(twap)),
+                funder: funder,
+                owner: address(safe1),
+                salt: SALT,
+                staticInput: abi.encode(_bundle())
+            })
+        );
+
+        assertEq(
+            id,
+            poller.scheduleId(
+                funder,
+                IConditionalOrderGenerator(address(twap)),
+                address(safe1),
+                SALT
+            ),
+            "id matches the off-chain derivation"
+        );
+    }
+
+    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();
+
+        (IConditionalOrderGenerator handler, address scheduleFunder, address owner, bytes32 salt,) =
+            poller.schedules(id);
+        assertEq(address(handler), address(twap), "handler stored");
+        assertEq(scheduleFunder, funder, "funder stored");
+        assertEq(owner, address(safe1), "owner stored");
+        assertEq(salt, SALT, "salt stored");
     }
 
-    function test_deployment() public {
-        assertTrue(address(poller) != address(0), "poller deployed");
+    /// @dev Only the funds source may register a schedule that draws on its own funds.
+    function test_register_RevertWhen_notFunder() public {
+        vm.expectRevert(ComposableCowPoller.OnlyFunder.selector);
+        poller.register(
+            ComposableCowPoller.Schedule({
+                handler: IConditionalOrderGenerator(address(twap)),
+                funder: funder, // attacker points at someone else's funds
+                owner: address(safe1),
+                salt: SALT,
+                staticInput: abi.encode(_bundle())
+            })
+        );
     }
 }