Update briefcase

Changes:
M	src/deployers/v2-core/UniswapV2FactoryDeployer.sol
A	src/protocols/uniswapx/v4/base/ReactorStructs.sol
A	src/protocols/uniswapx/v4/hooks/dca/DCAStructs.sol
A	src/protocols/uniswapx/v4/interfaces/IAuctionResolver.sol
A	src/protocols/uniswapx/v4/interfaces/IDCAHook.sol
A	src/protocols/uniswapx/v4/interfaces/IHook.sol
A	src/protocols/uniswapx/v4/interfaces/IReactor.sol

Author: github-actions[bot]

src/deployers/v2-core/UniswapV2FactoryDeployer.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {InputToken, OutputToken} from '../../base/ReactorStructs.sol';
+import {IAuctionResolver} from '../interfaces/IAuctionResolver.sol';
+import {IPostExecutionHook, IPreExecutionHook} from '../interfaces/IHook.sol';
+import {IReactor} from '../interfaces/IReactor.sol';
+
+/// @dev generic order information
+///  should be included as the first field in any concrete order types
+struct OrderInfo {
+    // The address of the reactor that this order is targeting
+    // Note that this must be included in every order so the swapper
+    // signature commits to the specific reactor that they trust to fill their order properly
+    IReactor reactor;
+    // The address of the user which created the order
+    // Note that this must be included so that order hashes are unique by swapper
+    address swapper;
+    // The nonce of the order, allowing for signature replay protection and cancellation
+    uint256 nonce;
+    // The timestamp after which this order is no longer valid
+    uint256 deadline;
+    // Pre-execution hook contract
+    IPreExecutionHook preExecutionHook;
+    // Encoded pre-execution hook data
+    bytes preExecutionHookData;
+    // Post-execution hook contract
+    IPostExecutionHook postExecutionHook;
+    // Encoded post-execution hook data
+    bytes postExecutionHookData;
+    // Auction resolver contract
+    IAuctionResolver auctionResolver;
+}
+
+/// @dev generic concrete order that specifies exact tokens which need to be sent and received
+struct ResolvedOrder {
+    OrderInfo info;
+    InputToken input;
+    OutputToken[] outputs;
+    bytes sig;
+    bytes32 hash; // The witness hash that includes resolver address and full order (what was signed)
+    address auctionResolver;
+    // Witness type string provided by resolver for Permit2 verification
+    string witnessTypeString;
+}

src/protocols/uniswapx/v4/base/ReactorStructs.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.0;
+
+import {IAllowanceTransfer} from '../../../../permit2/interfaces/IAllowanceTransfer.sol';
+
+struct FeedInfo {
+    bytes32 feedId;
+    address feed_address;
+    string feedType;
+}
+
+struct DCAIntent {
+    address swapper;
+    uint256 nonce;
+    uint256 chainId;
+    address hookAddress; // DCA contract's address
+    bool isExactIn; // EXACT_IN or EXACT_OUT
+    address inputToken; // Token to sell
+    address outputToken; // Token to buy
+    address cosigner; // TEE address that authorizes executions
+    uint256 minPeriod; // Minimum seconds between chunks
+    uint256 maxPeriod; // Maximum seconds between chunks
+    uint256 minChunkSize; // Min input or min output per chunk
+    uint256 maxChunkSize; // Max input or max output per chunk
+    uint256 minPrice; // Minimum price (output/input * 1e18)
+    uint256 deadline; // Intent expiration timestamp
+    OutputAllocation[] outputAllocations; // Distribution of output tokens
+    PrivateIntent privateIntent; // Private execution parameters - included in EIP-712 signature but zeroed on-chain, only hash revealed
+}
+
+struct PrivateIntent {
+    uint256 totalAmount; // Total amount on the exact side (input for EXACT_IN, output for EXACT_OUT)
+    uint256 exactFrequency;
+    uint256 numChunks;
+    bytes32 salt;
+    FeedInfo[] oracleFeeds; // Array of possible oracle feeds
+}
+
+struct OutputAllocation {
+    address recipient; // 20 bytes
+    uint16 basisPoints; // 2 bytes - Out of 10000 (100% = 10000), packed in same slot
+}
+
+struct DCAOrderCosignerData {
+    address swapper; // 20 bytes, slot 1
+    uint96 nonce; // 12 bytes
+    uint160 execAmount; // 20 bytes, slot 2
+    uint96 orderNonce; // 12 bytes Unique execution chunk identifier
+    uint160 limitAmount; // 20 bytes, slot 3 (12 bytes padding)
+    // uint160 matches Permit2's transferFrom amount limit
+}
+
+struct DCAExecutionState {
+    uint128 executedChunks; // 16 bytes slot 1 (perfectly packed)
+    uint120 lastExecutionTime; // 15 bytes
+    bool cancelled; // 1 byte
+    uint256 totalInputExecuted; // 32 bytes   slot 2 - Cumulative input amount
+    uint256 totalOutput; // 32 bytes   slot 3 - Cumulative output amount
+}
+
+struct PermitData {
+    bool hasPermit; // Whether a permit signature is included
+    IAllowanceTransfer.PermitSingle permitSingle; // The permit data (if hasPermit is true)
+    bytes signature; // The permit signature (if hasPermit is true)
+}

src/protocols/uniswapx/v4/hooks/dca/DCAStructs.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.2;
+
+import {SignedOrder} from '../../base/ReactorStructs.sol';
+import {ResolvedOrder} from '../base/ReactorStructs.sol';
+
+/// @notice Interface for auction mechanism resolvers (for UnifiedReactor)
+interface IAuctionResolver {
+    /// @notice Resolves a signed order into a resolved order based on auction rules
+    /// @param signedOrder The signed order with auction-specific order data (resolver address already stripped)
+    /// @return resolvedOrder The resolved order with final amounts
+    function resolve(SignedOrder calldata signedOrder) external view returns (ResolvedOrder memory resolvedOrder);
+
+    /// @notice Get the Permit2 order type string for EIP-712 signature verification
+    /// @return orderType The EIP-712 order type string for this resolver's orders
+    function getPermit2OrderType() external pure returns (string memory);
+}

src/protocols/uniswapx/v4/interfaces/IAuctionResolver.sol

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.2;
+
+import {DCAExecutionState} from '../hooks/dca/DCAStructs.sol';
+import {IPreExecutionHook} from './IHook.sol';
+
+/// @title IDCAHook
+/// @notice Interface for the DCA (Dollar-Cost Averaging) hook contract
+/// @dev Extends IPreExecutionHook to enable periodic execution of DCA intents
+interface IDCAHook is IPreExecutionHook {
+    /// @notice Thrown when attempting to cancel an already cancelled intent
+    /// @param intentId The identifier of the intent that was already cancelled
+    error IntentAlreadyCancelled(bytes32 intentId);
+
+    /// @notice Thrown when the swapper signature is invalid
+    /// @param recoveredSigner The address recovered from the signature
+    /// @param expectedSwapper The expected swapper address
+    error InvalidSwapperSignature(address recoveredSigner, address expectedSwapper);
+
+    /// @notice Thrown when the cosigner signature is invalid
+    /// @param recoveredCosigner The address recovered from the signature
+    /// @param expectedCosigner The expected cosigner address
+    error InvalidCosignerSignature(address recoveredCosigner, address expectedCosigner);
+
+    /// @notice Thrown when the cosigner data swapper doesn't match the intent swapper
+    /// @param cosignerSwapper The swapper address in cosigner data
+    /// @param intentSwapper The swapper address in the intent
+    error CosignerSwapperMismatch(address cosignerSwapper, address intentSwapper);
+
+    /// @notice Thrown when the cosigner data nonce doesn't match the intent nonce
+    /// @param cosignerNonce The nonce in cosigner data
+    /// @param intentNonce The nonce in the intent
+    error CosignerNonceMismatch(uint96 cosignerNonce, uint256 intentNonce);
+
+    /// @notice Thrown when output allocations array is empty
+    error EmptyAllocations();
+
+    /// @notice Thrown when an output allocation has zero basis points
+    error ZeroAllocation();
+
+    /// @notice Thrown when allocations don't sum to exactly 100% (10000 basis points)
+    /// @param totalBasisPoints The actual sum of basis points
+    error AllocationsNot100Percent(uint256 totalBasisPoints);
+
+    /// @notice Thrown when multiple allocations have the same recipient
+    /// @param recipient The duplicate recipient address
+    error DuplicateRecipient(address recipient);
+
+    /// @notice Thrown when the hook address doesn't match the expected hook
+    /// @param providedHook The hook address provided in the intent
+    /// @param expectedHook The expected hook address (this contract)
+    error WrongHook(address providedHook, address expectedHook);
+
+    /// @notice Thrown when the chain ID doesn't match the current chain
+    /// @param providedChainId The chain ID provided in the intent
+    /// @param currentChainId The current blockchain's chain ID
+    error WrongChain(uint256 providedChainId, uint256 currentChainId);
+
+    /// @notice Thrown when the swapper address doesn't match between intent and order
+    /// @param orderSwapper The swapper address in the resolved order
+    /// @param intentSwapper The swapper address in the intent
+    error SwapperMismatch(address orderSwapper, address intentSwapper);
+
+    /// @notice Thrown when the input token doesn't match the intent
+    /// @param orderInputToken The input token in the resolved order
+    /// @param intentInputToken The input token in the intent
+    error WrongInputToken(address orderInputToken, address intentInputToken);
+
+    /// @notice Thrown when an output token doesn't match the intent
+    /// @param outputToken The output token in the resolved order
+    /// @param expectedToken The expected output token from the intent
+    error WrongOutputToken(address outputToken, address expectedToken);
+
+    /// @notice Thrown when chunk size is below minimum allowed
+    /// @param amount The actual chunk size (input for EXACT_IN, output for EXACT_OUT)
+    /// @param minChunkSize The minimum allowed chunk size
+    error ChunkSizeBelowMin(uint256 amount, uint256 minChunkSize);
+
+    /// @notice Thrown when chunk size exceeds maximum allowed
+    /// @param amount The actual chunk size (input for EXACT_IN, output for EXACT_OUT)
+    /// @param maxChunkSize The maximum allowed chunk size
+    error ChunkSizeAboveMax(uint256 amount, uint256 maxChunkSize);
+
+    /// @notice Thrown when input amount doesn't match execAmount (EXACT_IN)
+    /// @param inputAmount The input amount in the order
+    /// @param execAmount The expected exec amount from cosigner data
+    error InputAmountMismatch(uint256 inputAmount, uint256 execAmount);
+
+    /// @notice Thrown when input amount is zero (EXACT_OUT)
+    error ZeroInput();
+
+    /// @notice Thrown when input exceeds cosigner's limit (EXACT_OUT)
+    /// @param inputAmount The actual input amount
+    /// @param limitAmount The cosigner's limit amount
+    error InputAboveLimit(uint256 inputAmount, uint256 limitAmount);
+
+    /// @notice Thrown when attempting to execute a cancelled intent
+    /// @param intentId The identifier of the cancelled intent
+    error IntentIsCancelled(bytes32 intentId);
+
+    /// @notice Thrown when the intent has expired
+    /// @param currentTime The current block timestamp
+    /// @param deadline The intent's deadline
+    error IntentExpired(uint256 currentTime, uint256 deadline);
+
+    /// @notice Thrown when the order nonce doesn't match the expected nonce
+    /// @param providedNonce The nonce provided in the cosigner data
+    /// @param expectedNonce The expected next nonce for the intent
+    error WrongChunkNonce(uint96 providedNonce, uint96 expectedNonce);
+
+    /// @notice Thrown when execution is attempted too soon after the last execution
+    /// @param elapsed The time elapsed since last execution
+    /// @param minPeriod The minimum required period between executions
+    error TooSoon(uint256 elapsed, uint256 minPeriod);
+
+    /// @notice Thrown when execution is attempted too late after the last execution
+    /// @param elapsed The time elapsed since last execution
+    /// @param maxPeriod The maximum allowed period between executions
+    error TooLate(uint256 elapsed, uint256 maxPeriod);
+
+    /// @notice Thrown when the execution price is below the minimum price floor
+    /// @param executionPrice The actual execution price (scaled by 1e18)
+    /// @param minPrice The minimum acceptable price (scaled by 1e18)
+    error PriceBelowMin(uint256 executionPrice, uint256 minPrice);
+
+    /// @notice Thrown when output allocation doesn't match expected amount
+    /// @param recipient The recipient address
+    /// @param actual The actual amount allocated to the recipient
+    /// @param expected The expected amount for the recipient
+    error AllocationMismatch(address recipient, uint256 actual, uint256 expected);
+
+    /// @notice Thrown when total output is insufficient (EXACT_IN)
+    /// @param totalOutput The total output amount produced
+    /// @param limitAmount The minimum required output amount
+    error InsufficientOutput(uint256 totalOutput, uint256 limitAmount);
+
+    /// @notice Thrown when total output doesn't match expected amount (EXACT_OUT)
+    /// @param totalOutput The actual total output amount
+    /// @param execAmount The expected exact output amount
+    error WrongTotalOutput(uint256 totalOutput, uint256 execAmount);
+
+    /// @notice Emitted when an intent is cancelled
+    /// @param intentId The unique identifier of the intent
+    /// @param swapper The address of the swapper who cancelled the intent
+    event IntentCancelled(bytes32 indexed intentId, address indexed swapper);
+
+    /// @notice Emitted when a DCA chunk is executing
+    /// @param intentId The unique identifier of the intent
+    /// @param execAmount The amount being executed (input for EXACT_IN, output for EXACT_OUT)
+    /// @param limitAmount The limit amount (min output for EXACT_IN, max input for EXACT_OUT)
+    /// @param totalInputExecuted Cumulative input amount after this execution
+    /// @param totalOutput Cumulative output amount after this execution
+    event ChunkExecuted(
+        bytes32 indexed intentId,
+        uint256 execAmount,
+        uint256 limitAmount,
+        uint256 totalInputExecuted,
+        uint256 totalOutput
+    );
+
+    /// @notice Cancel a single DCA intent
+    /// @param nonce The nonce of the intent to cancel
+    /// @dev Only callable by the intent owner (verified via msg.sender and nonce)
+    function cancelIntent(uint256 nonce) external;
+
+    /// @notice Cancel multiple DCA intents in a single transaction
+    /// @param nonces Array of intent nonces to cancel
+    /// @dev Only callable by the intent owner for each intent (verified via msg.sender and nonces)
+    function cancelIntents(uint256[] calldata nonces) external;
+
+    /// @notice Compute the unique identifier for an intent
+    /// @param swapper The address of the swapper
+    /// @param nonce The nonce of the intent
+    /// @return intentId The computed intent identifier
+    function computeIntentId(address swapper, uint256 nonce) external pure returns (bytes32);
+
+    /// @notice Get the execution state for a specific intent
+    /// @param intentId The unique identifier of the intent
+    /// @return state The execution state of the intent
+    function getExecutionState(bytes32 intentId) external view returns (DCAExecutionState memory state);
+
+    /// @notice Check if an intent is currently active (not cancelled and within period/deadline)
+    /// @dev Semantics:
+    /// - Uninitialized intents (no executed chunks) are considered active unless cancelled or past deadline.
+    /// - maxPeriod is enforced only after the first execution; before that, it is ignored.
+    /// - A maxPeriod of 0 means no upper bound; a deadline of 0 means no deadline.
+    /// @param intentId The unique identifier of the intent
+    /// @param maxPeriod The maximum allowed seconds since last execution (0 = no upper bound)
+    /// @param deadline The intent expiration timestamp (0 = no deadline)
+    /// @return active True if the intent is active, false otherwise
+    function isIntentActive(bytes32 intentId, uint256 maxPeriod, uint256 deadline) external view returns (bool active);
+
+    /// @notice Get the next expected nonce for an intent
+    /// @param intentId The unique identifier of the intent
+    /// @return nextNonce The next nonce that should be used for this intent
+    function getNextNonce(bytes32 intentId) external view returns (uint96 nextNonce);
+
+    /// @notice Get comprehensive statistics for an intent
+    /// @param intentId The unique identifier of the intent
+    /// @return totalChunks Number of chunks executed
+    /// @return totalInput Total input amount executed
+    /// @return totalOutput Total output amount received
+    /// @return lastExecutionTime Timestamp of last execution
+    function getIntentStatistics(bytes32 intentId)
+        external
+        view
+        returns (uint256 totalChunks, uint256 totalInput, uint256 totalOutput, uint256 lastExecutionTime);
+}

src/protocols/uniswapx/v4/interfaces/IDCAHook.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.2;
+
+import {ResolvedOrder} from '../base/ReactorStructs.sol';
+
+/// @notice Hook to be called before order execution, allowing state modifications
+interface IPreExecutionHook {
+    /// @notice Called by the reactor before order execution for custom validation and state changes
+    /// @param filler The filler of the order
+    /// @param resolvedOrder The resolved order to fill
+    function preExecutionHook(address filler, ResolvedOrder calldata resolvedOrder) external;
+}
+
+/// @notice Hook to be called after transferring output tokens, enabling chained actions
+interface IPostExecutionHook {
+    /// @notice Called by the reactor after order execution for chained actions
+    /// @param filler The filler of the order
+    /// @param resolvedOrder The resolved order that was filled
+    function postExecutionHook(address filler, ResolvedOrder calldata resolvedOrder) external;
+}

src/protocols/uniswapx/v4/interfaces/IHook.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity >=0.6.2;
+
+import {SignedOrder} from '../../base/ReactorStructs.sol';
+
+/// @notice Interface for order execution reactors
+interface IReactor {
+    /// @notice thrown when an auction resolver is not set
+    error EmptyAuctionResolver();
+    /// @notice thrown when the order targets a different reactor
+    error InvalidReactor();
+    /// @notice thrown when the order's deadline has passed
+    error DeadlinePassed();
+    /// @notice thrown when a pre-execution hook is not set
+    error MissingPreExecutionHook();
+    /// @notice thrown when resolver addr encoded in SignedOrder doesn't match signed resolver in OrderInfo
+    error ResolverMismatch();
+
+    /// @notice Execute a single order
+    /// @param order The order definition and valid signature to execute
+    function execute(SignedOrder calldata order) external payable;
+
+    /// @notice Execute a single order using the given callback data
+    /// @param order The order definition and valid signature to execute
+    /// @param callbackData The callbackData to pass to the callback
+    function executeWithCallback(SignedOrder calldata order, bytes calldata callbackData) external payable;
+
+    /// @notice Execute the given orders at once
+    /// @param orders The order definitions and valid signatures to execute
+    function executeBatch(SignedOrder[] calldata orders) external payable;
+
+    /// @notice Execute the given orders at once using a callback with the given callback data
+    /// @param orders The order definitions and valid signatures to execute
+    /// @param callbackData The callbackData to pass to the callback
+    function executeBatchWithCallback(SignedOrder[] calldata orders, bytes calldata callbackData) external payable;
+}