feat: ExecutionBoundEnforcer — exact execution commitment at redemption

[terriclaw]

Description

Add ExecutionBoundEnforcer, a CaveatEnforcer that binds execution to an EIP-712 signed commitment at redemption.

Existing caveats enforce policy constraints, but not exact execution. Requires exact equality between execution and a pre-signed ExecutionIntent.

---

Technical Details

• Inherits CaveatEnforcer
• terms: unused (0x)
• args: abi.encode(ExecutionIntent intent, address signer, bytes signature)
• ExecutionIntent: (account, target, value, dataHash, nonce, deadline)
• dataHash = keccak256(execution.callData)
• Nonce scoped by (delegationManager, account, nonce)
• Nonce is consumed before signature verification (CEI)
• Supports EOA + ERC-1271 signatures via SignatureChecker
• Restricted to single-call + default execution mode
• EIP-712 domain anchored to enforcer contract address

---

Acceptance Criteria

• exact execution passes
• mutated calldata reverts (DataHashMismatch)
• replay reverts (NonceAlreadyUsed)
• unsupported call type reverts (CaveatEnforcer:invalid-call-type)
• signer distinct from delegator passes with valid signature
• wrong signer reverts (InvalidSignature)
• wrong account reverts (AccountMismatch)
• expired deadline reverts (IntentExpired)

---

References

• Implementation: https://github.com/terriclaw/execution-bound-intent
• Port branch: https://github.com/terriclaw/delegation-framework/tree/feat/execution-bound-enforcer

[MoMannn]

I believe ExactExecutionEnforcer is what you are looking for. You can combine it with LimitedCallsEnforcer and/or TimestampEnforcer.

As for the "third party signer" that is allowed to sign the calldata. You should delegate to that signer (with basic restrictions) and they can redelegate with ExactExecutionEnforcer at execution time. If that is desired case.

[terriclaw]

Agreed that exact calldata matching is already covered via ExactExecutionEnforcer + composition.

What I was trying to explore is whether execution intent at redemption (exact execution + signer + nonce + deadline) is better treated as a single atomic boundary or left as composed pieces.

In the composed model, those guarantees are split across multiple enforcers and delegation wiring. In this approach, they’re carried in a single signed intent and enforced together at redemption.

Totally understand if the framework prefers keeping this composable—happy to treat this as a higher-level pattern / SDK rather than a core primitive.