deploy: SentinelHookV1 live on Unichain Sepolia + fee-curve demo

- hook: 0x290d2d0af6dd11b6e235eac6d7528f5474753080 (CREATE2, 0x...3080
  permission suffix, tx 0xcaeb7fb3…442029)
- V1 demo pool created on STA/STB with liquidity
- demo choreography on-chain: calm swap pays 5bps base; sustained trend
  ramps the fee continuously 500 -> 7704 (rate-limited steps, FeeUpdated
  events); 2h quiet decays back at -500/step toward base
- BaseScript: hook binding now env-overridable (SENTINEL_HOOK_ADDRESS),
  default unchanged (V0)
- scripts: 05_DeployHookV1.s.sol, 06_DemoSwapsV1.s.sol

Author: chaosxcode

broadcast/01_CreatePoolAndAddLiquidity.s.sol/1301/run-1787525657827.json

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {HookMiner} from "@uniswap/v4-periphery/src/utils/HookMiner.sol";
+
+import {BaseScript} from "./base/BaseScript.sol";
+import {console2} from "forge-std/console2.sol";
+
+import {SentinelHookV1} from "../src/SentinelHookV1.sol";
+
+/// @notice Mines the address and deploys the SentinelHookV1.sol Hook contract
+///         (continuous vol-EMA toxicity pricing). Same permission bits as V0:
+///         beforeInitialize | afterInitialize | beforeSwap.
+contract DeployHookV1Script is BaseScript {
+    function run() public {
+        // hook contracts must have specific flags encoded in the address
+        uint160 flags =
+            uint160(Hooks.BEFORE_INITIALIZE_FLAG | Hooks.AFTER_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG);
+
+        // Mine a salt that will produce a hook address with the correct flags
+        bytes memory constructorArgs = abi.encode(poolManager);
+        (address hookAddress, bytes32 salt) =
+            HookMiner.find(CREATE2_FACTORY, flags, type(SentinelHookV1).creationCode, constructorArgs);
+
+        // Deploy the hook using CREATE2
+        vm.startBroadcast();
+        SentinelHookV1 sentinel = new SentinelHookV1{salt: salt}(poolManager);
+        vm.stopBroadcast();
+
+        require(address(sentinel) == hookAddress, "DeployHookV1Script: Hook Address Mismatch");
+
+        console2.log("SentinelHookV1 deployed:", address(sentinel));
+        console2.log("salt:", vm.toString(salt));
+    }
+}

broadcast/01_CreatePoolAndAddLiquidity.s.sol/1301/run-latest.json

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+import {LPFeeLibrary} from "@uniswap/v4-core/src/libraries/LPFeeLibrary.sol";
+import {console2} from "forge-std/console2.sol";
+
+import {BaseScript} from "./base/BaseScript.sol";
+import {SentinelHookV1} from "../src/SentinelHookV1.sol";
+
+/// @notice Demo choreography for the live SentinelHookV1 pool:
+///   1. a calm swap — fee stays at the 0.05% base,
+///   2. a sustained one-directional trend — realized volatility over the
+///      60-second lookback feeds the EMA and the fee ramps toward the 1.00%
+///      cap, rate-limited to 0.05% per update, one FeeUpdated event per step.
+///   3. quiet — the EMA decays and the fee eases back toward base.
+contract DemoSwapsV1Script is BaseScript {
+    using PoolIdLibrary for PoolKey;
+
+    function run() external {
+        PoolKey memory poolKey = PoolKey({
+            currency0: currency0,
+            currency1: currency1,
+            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
+            tickSpacing: 60,
+            hooks: hookContract
+        });
+        bytes memory hookData = new bytes(0);
+        SentinelHookV1 hook = SentinelHookV1(address(hookContract));
+        PoolId poolId = poolKey.toId();
+
+        vm.startBroadcast();
+
+        token0.approve(address(swapRouter), type(uint256).max);
+        token1.approve(address(swapRouter), type(uint256).max);
+
+        // 1. Calm swap — pays the base fee.
+        swapRouter.swapExactTokensForTokens({
+            amountIn: 0.02e18,
+            amountOutMin: 0,
+            zeroForOne: true,
+            poolKey: poolKey,
+            hookData: hookData,
+            receiver: deployerAddress,
+            deadline: block.timestamp + 300
+        });
+        console2.log("1) calm swap fee:", hook.getCurrentFee(poolId));
+
+        // 2. Sustained trend: repeated same-direction swaps. Each pays the
+        // fee set BEFORE it executes; the EMA feeds on realized moves.
+        uint24 prev = hook.getCurrentFee(poolId);
+        for (uint256 i = 0; i < 45; i++) {
+            vm.warp(block.timestamp + 3);
+            swapRouter.swapExactTokensForTokens({
+                amountIn: 0.1e18,
+                amountOutMin: 0,
+                zeroForOne: false,
+                poolKey: poolKey,
+                hookData: hookData,
+                receiver: deployerAddress,
+                deadline: block.timestamp + 300
+            });
+            uint24 fee = hook.getCurrentFee(poolId);
+            if (fee != prev) {
+                console2.log("2) ramp step:", fee);
+                prev = fee;
+            }
+        }
+        require(prev > hook.BASE_FEE(), "demo: fee did not ramp");
+        require(prev <= hook.CAP_FEE(), "demo: fee above cap");
+
+        // 3. Quiet period: EMA decays; fee steps back down.
+        vm.warp(block.timestamp + 2 hours);
+        for (uint256 i = 0; i < 45; i++) {
+            vm.warp(block.timestamp + 3);
+            swapRouter.swapExactTokensForTokens({
+                amountIn: 0.001e18,
+                amountOutMin: 0,
+                zeroForOne: true,
+                poolKey: poolKey,
+                hookData: hookData,
+                receiver: deployerAddress,
+                deadline: block.timestamp + 300
+            });
+            uint24 fee = hook.getCurrentFee(poolId);
+            if (fee != prev) {
+                console2.log("3) decay step:", fee);
+                prev = fee;
+            }
+        }
+        console2.log("final fee:", prev);
+        console2.log("ema (wad):", hook.getEmaRateWad(poolId));
+
+        vm.stopBroadcast();
+    }
+}

broadcast/05_DeployHookV1.s.sol/1301/run-1787525429812.json

@@ -24,7 +24,7 @@ contract BaseScript is Script, Deployers {
     /////////////////////////////////////
     IERC20 internal constant token0 = IERC20(0x345A187ace5808B0F7030d82cB2b444AcDa8Af1C); // Sentinel Test Alpha (Unichain Sepolia)
     IERC20 internal constant token1 = IERC20(0x52611F5C1e35E3213E5155483311A2C9Ab310138); // Sentinel Test Beta (Unichain Sepolia)
-    IHooks constant hookContract = IHooks(0xCbD5bAc7B96770d7f18b97D05d6518A4D0913080); // SentinelHookV0 (Unichain Sepolia)
+    IHooks immutable hookContract; // SentinelHookV0 by default; set SENTINEL_HOOK_ADDRESS to bind another (e.g. V1)
     /////////////////////////////////////
 
     Currency immutable currency0;
@@ -46,6 +46,7 @@ contract BaseScript is Script, Deployers {
         vm.label(address(token0), "Currency0");
         vm.label(address(token1), "Currency1");
 
+        hookContract = IHooks(vm.envOr("SENTINEL_HOOK_ADDRESS", 0xCbD5bAc7B96770d7f18b97D05d6518A4D0913080));
         vm.label(address(hookContract), "HookContract");
     }