@agenticprimitives/contracts 1.0.0-alpha.21 → 1.0.0-alpha.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticprimitives/contracts",
-  "version": "1.0.0-alpha.21",
+  "version": "1.0.0-alpha.22",
   "description": "Solidity contracts + ABIs + flattened sources + per-network deployment addresses for the agenticprimitives stack.",
   "license": "MIT",
   "repository": {

package/src/AgentAccount.sol

@@ -1112,6 +1112,17 @@ contract AgentAccount is
     ///      EntryPoint / self / DelegationManager; the guard hardens
     ///      against a malicious target re-entering through one of those
     ///      callers.
+    ///
+    ///      Slither reports `reentrancy-eth` here because `_delegationExecCtx`
+    ///      is written after the external calls. The write is `= false`, and the
+    ///      flag is RESTRICTIVE while set: `_rejectDelegatedGovernance` reverts a
+    ///      delegation-originated governance self-call only when it is true. A
+    ///      reentrant frame therefore observes the *more* restricted state, never
+    ///      a bypass — and the only readers of the flag are `execute` (guarded by
+    ///      `nonReentrant` on this very function) and `executeBatch`, whose own
+    ///      exemption is justified at its declaration. The flag is transient
+    ///      (EIP-1153), so it cannot survive the transaction either.
+    // slither-disable-next-line reentrancy-eth
     function execute(address target, uint256 value, bytes calldata data) external override nonReentrant whenNotPaused {
         _requireForExecute();
 
@@ -1174,6 +1185,15 @@ contract AgentAccount is
     ///      OUTER `execute` already holds the guard, so external re-entry
     ///      is blocked; `_requireForExecute` restricts entry to
     ///      EntryPoint / self / DM (DM has its own `nonReentrant`).
+    ///
+    ///      Slither reports `reentrancy-eth` here for the same reason as
+    ///      `execute`, and it is a false positive for the same reason: the
+    ///      post-call write clears `_delegationExecCtx`, a transient flag that
+    ///      only ever *adds* a restriction while set. Note this function is
+    ///      deliberately un-guarded (see above), so the suppression is scoped to
+    ///      this detector on this declaration only — any other high-severity
+    ///      finding here still fails the build.
+    // slither-disable-next-line reentrancy-eth
     function executeBatch(Call[] calldata calls) external override whenNotPaused {
         _requireForExecute();
 

package/src/AgentAccountFactory.sol

@@ -357,8 +357,18 @@ contract AgentAccountFactory is GovernanceManaged {
             if (thresholds[5] > sodCap) thresholds[5] = sodCap;
         }
 
+        // DEV/TEST-CHAIN CARVE-OUT (local demo only): on a local development chain the T4 floor is lifted
+        // so a demo can drive an admin custody action's schedule→apply back-to-back without a real-time
+        // wait, and a zero override yields a ZERO T4 safety delay instead of the 1-hour production default.
+        // Gated strictly by `block.chainid` — anvil (31337/1337) and the local faithchain (34348). Every
+        // PRODUCTION and public TESTNET chain id (Base Sepolia 84532, mainnet, …) keeps the audited
+        // EXT-TL-FLOOR-1 invariant. T5 (24h) and T6 (recovery, 48h) are NOT relaxed even on dev — the
+        // CustodyPolicy requires a non-zero timelock for those tiers, and the demo only exercises T4.
+        bool devChain = block.chainid == 31337 || block.chainid == 1337 || block.chainid == 34348;
+        uint32 floor4 = devChain ? 0 : uint32(1 hours);
+
         uint32[7] memory timelocks;
-        timelocks[4] = timelockOverrides[4] == 0 ? uint32(1 hours)  : timelockOverrides[4];
+        timelocks[4] = timelockOverrides[4] == 0 ? floor4 : timelockOverrides[4];
         timelocks[5] = timelockOverrides[5] == 0 ? uint32(24 hours) : timelockOverrides[5];
         timelocks[6] = timelockOverrides[6] == 0 ? uint32(48 hours) : timelockOverrides[6];
 
@@ -366,8 +376,9 @@ contract AgentAccountFactory is GovernanceManaged {
         // below the product floor. A zero override inherits the floor default above; a non-zero override below
         // the floor reverts, so a mode>0 (custody-governed) account can never deploy with sub-floor T4/T5/T6
         // (recovery = T6) delays. The "T5=24h / recovery=48h" guarantee becomes a protocol invariant, not a UI
-        // convention (spec 300 — raise-only). Demo/testnet fast-timelock deploys use zero overrides (defaults).
-        if (timelocks[4] < 1 hours)  revert TimelockBelowFloor(4, timelocks[4], uint32(1 hours));
+        // convention (spec 300 — raise-only). The T4 floor is `floor4` (production value on real chains, 0 on
+        // the dev-chain carve-out); T5/T6 keep their audited floors on every chain.
+        if (timelocks[4] < floor4) revert TimelockBelowFloor(4, timelocks[4], floor4);
         if (timelocks[5] < 24 hours) revert TimelockBelowFloor(5, timelocks[5], uint32(24 hours));
         if (timelocks[6] < 48 hours) revert TimelockBelowFloor(6, timelocks[6], uint32(48 hours));