• mediumSell tax required by the brief is not implemented: sells into the pool pay 0% instead of 3%src/MADToken.sol:83

  The brief specifies a '3% buy/sell tax that goes to 0x1EE3ffadfE138415A2ddaedeEBe5F46616fA413d'. _update only taxes transfers whose sender is the PoolManager (buys); a transfer into the PoolManager (a sell) moves whole and pays nothing. The README states this deliberately (a deducted tax on a transfer into the v4 PoolManager would leave the swap unsettled), but the requester receives half of the tax they specified: a buy+sell round trip pays 3% instead of ~6%.

  This is a requirement/implementation mismatch the requester must decide on (accept buy-only, raise the buy rate, or collect the sell side some other way, e.g. a fee-taking pool hook), not something the tests can assert as correct. The suites delivered here assert that every buy pays at least its 3% and that every sell settles (the launch floor), and deliberately do not assert that sells are untaxed.

  Real v4 PoolManager, MAD/pair pool at 1:1, fee 12500, tick spacing 60, liquidity 1e24 over ticks [-60000, 60000].

  A trader holding 1,000 MAD (received off-pool) swaps exact-input 1,000 MAD for the pair token.

  Expected per brief: tax wallet +30 MAD.

  Actual: tax wallet +0 (proof fails with 'a 1,000 MAD sell paid no sell tax: 0 < 30000000000000000000').

  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {Test} from "forge-std/Test.sol";
  import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
  import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  import {PoolManager} from "v4-core/src/PoolManager.sol";
  import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
  import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
  import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
  import {PoolKey} from "v4-core/src/types/PoolKey.sol";
  import {Currency} from "v4-core/src/types/Currency.sol";
  import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
  import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
  import {TickMath} from "v4-core/src/libraries/TickMath.sol";
  import {MADToken} from "src/MADToken.sol";
  
  contract ProofPair is ERC20 {
      constructor() ERC20("Pair", "PAIR") {}
  
      function mint(address to, uint256 amount) external {
          _mint(to, amount);
      }
  }
  
  contract ProofActor is IUnlockCallback {
      IPoolManager immutable manager;
  
      constructor(IPoolManager manager_) {
          manager = manager_;
      }
  
      function _settle(Currency currency, int128 delta) internal {
          if (delta < 0) {
              manager.sync(currency);
              IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(uint128(-delta)));
              manager.settle();
          } else if (delta > 0) {
              manager.take(currency, address(this), uint256(uint128(delta)));
          }
      }
  
      function addLiquidity(PoolKey calldata key, int256 liquidity) external {
          manager.unlock(abi.encode(uint8(0), key, liquidity, false));
      }
  
      function swap(PoolKey calldata key, bool zeroForOne, int256 amount) external {
          manager.unlock(abi.encode(uint8(1), key, amount, zeroForOne));
      }
  
      function unlockCallback(bytes calldata data) external returns (bytes memory) {
          (uint8 kind, PoolKey memory key, int256 amount, bool zeroForOne) = abi.decode(data, (uint8, PoolKey, int256, bool));
          BalanceDelta delta;
          if (kind == 0) {
              (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-60_000, 60_000, amount, bytes32(0)), "");
          } else {
              uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
              delta = manager.swap(key, SwapParams(zeroForOne, amount, limit), "");
          }
          _settle(key.currency0, delta.amount0());
          _settle(key.currency1, delta.amount1());
          return "";
      }
  }
  
  /// The brief: "3% buy/sell tax that goes to 0x1EE3...413d". A sell of MAD into the v4 pool pays nothing.
  contract SellTaxProof is Test {
      address constant TAX_WALLET = 0x1EE3ffadfE138415A2ddaedeEBe5F46616fA413d;
  
      function test_aSellIntoThePoolPaysTheThreePercentTax() public {
          PoolManager manager = new PoolManager(address(this));
          ProofPair pair = new ProofPair();
          MADToken token = new MADToken(address(this), address(manager));
          bool tokenIsZero = address(token) < address(pair);
          PoolKey memory key = tokenIsZero
              ? PoolKey(Currency.wrap(address(token)), Currency.wrap(address(pair)), 12_500, 60, IHooks(address(0)))
              : PoolKey(Currency.wrap(address(pair)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(0)));
          manager.initialize(key, 79_228_162_514_264_337_593_543_950_336);
  
          ProofActor lp = new ProofActor(manager);
          token.transfer(address(lp), 10_000_000e18);
          pair.mint(address(lp), 10_000_000e18);
          lp.addLiquidity(key, 1_000_000e18);
  
          // The seller got its MAD off-pool (e.g. a distributor claim), so no buy tax is involved.
          ProofActor seller = new ProofActor(manager);
          token.transfer(address(seller), 1_000e18);
          uint256 taxBefore = token.balanceOf(TAX_WALLET);
  
          seller.swap(key, tokenIsZero, -1_000e18); // sell 1,000 MAD, exact input
  
          // Expected: the tax wallet receives 3% of the 1,000 MAD sold (30 MAD). Actual: 0.
          assertGe(token.balanceOf(TAX_WALLET) - taxBefore, 30e18, "a 1,000 MAD sell paid no sell tax");
      }
  }

  whole proof

• lowBuy tax is bypassed when the MAD output is kept as a Uniswap v4 ERC-6909 claimsrc/MADToken.sol:83

  The buy tax is charged only when MAD physically leaves the PoolManager (from == POOL_MANAGER). A router that settles a buy with manager.mint (ERC-6909 claim) instead of manager.take never moves MAD, so no tax is charged. Claims can be transferred between accounts and spent on a later sell (manager.burn) without any MAD transfer either, so a trader who stays in claims trades MAD with zero tax in both directions.

  Only converting a claim back to ERC-20 MAD (take) is taxed. Combined with the untaxed sell this lets sophisticated traders avoid the tax entirely.

  Same pool as above.

  A buyer swaps exact-input 1,000 pair for MAD and settles the MAD output with manager.mint(buyer, id(MAD), delta).

  Buyer receives ~1,017 MAD of claims.

  Expected: tax wallet receives 3% of the gross output (~30.5 MAD).

  Actual: 0 (proof fails with 'a buy settled as a claim paid no buy tax: 0 < 30511107394849647828').

  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {Test} from "forge-std/Test.sol";
  import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
  import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  import {PoolManager} from "v4-core/src/PoolManager.sol";
  import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
  import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
  import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
  import {PoolKey} from "v4-core/src/types/PoolKey.sol";
  import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
  import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
  import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
  import {TickMath} from "v4-core/src/libraries/TickMath.sol";
  import {MADToken} from "src/MADToken.sol";
  
  contract ClaimsPair is ERC20 {
      constructor() ERC20("Pair", "PAIR") {}
  
      function mint(address to, uint256 amount) external {
          _mint(to, amount);
      }
  }
  
  /// Settles inputs normally, but keeps a MAD output as an ERC-6909 claim (manager.mint) instead of take.
  contract ClaimsActor is IUnlockCallback {
      using CurrencyLibrary for Currency;
  
      IPoolManager immutable manager;
      address immutable mad;
  
      constructor(IPoolManager manager_, address mad_) {
          manager = manager_;
          mad = mad_;
      }
  
      function _settle(Currency currency, int128 delta) internal {
          if (delta < 0) {
              manager.sync(currency);
              IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(uint128(-delta)));
              manager.settle();
          } else if (delta > 0) {
              if (Currency.unwrap(currency) == mad) manager.mint(address(this), currency.toId(), uint256(uint128(delta)));
              else manager.take(currency, address(this), uint256(uint128(delta)));
          }
      }
  
      function addLiquidity(PoolKey calldata key, int256 liquidity) external {
          manager.unlock(abi.encode(uint8(0), key, liquidity, false));
      }
  
      function swap(PoolKey calldata key, bool zeroForOne, int256 amount) external {
          manager.unlock(abi.encode(uint8(1), key, amount, zeroForOne));
      }
  
      function unlockCallback(bytes calldata data) external returns (bytes memory) {
          (uint8 kind, PoolKey memory key, int256 amount, bool zeroForOne) = abi.decode(data, (uint8, PoolKey, int256, bool));
          BalanceDelta delta;
          if (kind == 0) {
              (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-60_000, 60_000, amount, bytes32(0)), "");
          } else {
              uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
              delta = manager.swap(key, SwapParams(zeroForOne, amount, limit), "");
          }
          _settle(key.currency0, delta.amount0());
          _settle(key.currency1, delta.amount1());
          return "";
      }
  }
  
  /// A buy whose MAD output is kept as a v4 ERC-6909 claim never moves MAD out of the PoolManager,
  /// so the 3% buy tax is never charged on it.
  contract ClaimsBypassProof is Test {
      using CurrencyLibrary for Currency;
  
      address constant TAX_WALLET = 0x1EE3ffadfE138415A2ddaedeEBe5F46616fA413d;
  
      function test_aBuyHeldAsAClaimPaysTheBuyTax() public {
          PoolManager manager = new PoolManager(address(this));
          ClaimsPair pair = new ClaimsPair();
          MADToken token = new MADToken(address(this), address(manager));
          bool tokenIsZero = address(token) < address(pair);
          PoolKey memory key = tokenIsZero
              ? PoolKey(Currency.wrap(address(token)), Currency.wrap(address(pair)), 12_500, 60, IHooks(address(0)))
              : PoolKey(Currency.wrap(address(pair)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(0)));
          manager.initialize(key, 79_228_162_514_264_337_593_543_950_336);
  
          ClaimsActor lp = new ClaimsActor(manager, address(token));
          token.transfer(address(lp), 10_000_000e18);
          pair.mint(address(lp), 10_000_000e18);
          lp.addLiquidity(key, 1_000_000e18);
  
          ClaimsActor buyer = new ClaimsActor(manager, address(token));
          pair.mint(address(buyer), 1_000e18);
          buyer.swap(key, !tokenIsZero, -1_000e18); // buy MAD with 1,000 pair, exact input
  
          uint256 bought = manager.balanceOf(address(buyer), Currency.wrap(address(token)).toId());
          assertGt(bought, 900e18, "the buyer received its MAD as a claim");
          // Expected: 3% of the MAD bought goes to the tax wallet. Actual: 0.
          assertGe(token.balanceOf(TAX_WALLET), (bought * 300) / 9_700, "a buy settled as a claim paid no buy tax");
      }
  }

  whole proof

• infoLiquidity providers pay the 3% buy tax on every MAD they withdraw, including earned feessrc/MADToken.sol:83

  Any MAD leaving the PoolManager to a non-exempt address is treated as a buy. Removing liquidity, collecting MAD fees, and even adding to an existing position whose accrued MAD fees exceed the deposit (the net delta pays out) all deliver 97% to the LP and 3% to the tax wallet. Only the factory is exempt.

  Third-party LPs therefore lose 3% of their MAD principal on exit; worth stating to the requester and to front-ends. The invariant suite test/MADTokenV4Invariant.t.sol models this explicitly (it surfaced the fee-payout-on-add case).

  Add liquidity over [-60000,60000], let trades accrue MAD fees, then call modifyLiquidity with a small positive liquidityDelta: the MAD delta is positive and the take of X MAD delivers 0.97X to the LP and 0.03X to 0x1EE3...413d (observed: take of 43280037848608777 wei delivered 41981636713150514, tax 1298401135458263).

• mediumSell leg is untaxed: the brief's 3% buy/sell tax is delivered as a 3% buy-only taxsrc/MADToken.sol:92

  The requester specified a 3% buy/sell tax paid to 0x1EE3ffadfE138415A2ddaedeEBe5F46616fA413d. _update splits only transfers whose sender is the PoolManager (line 83).

  A transfer whose recipient is the PoolManager (a sell) falls through to the plain OpenZeppelin update at line 92 and pays nothing, so a buy+sell round trip carries 3% instead of the 6% the brief implies, and a holder who received MAD untaxed (distributor claim, remainder allocation, wallet-to-wallet) sells into the pool paying nothing at all.

  The README discloses this and its reasoning is correct for a token-level tax: Uniswap v4 credits a sell by the PoolManager's balance change between sync and settle, so a token that deducts 3% from a transfer into the PoolManager leaves the swap 3% unsettled and the launch floor's trader (Token.protected.t.sol test_theSeedAndASwapEachWaySucceed: swap exact input, then settle) reverts with CurrencyNotSettled; charging the 3% on top is refused by the same floor test because it sells the trader's whole bought balance; a tax taken only from a seller's remaining balance is avoided by selling everything.

  So this is not a coding slip but an unmet requirement that needs the requester's explicit decision rather than a README note: (a) accept buy-only at 3% as built, (b) set TAX_BPS to 600 on the buy leg so the round trip carries the intended 6% (one-constant change, still passes the floor), or (c) move the sell-side tax to a venue the token can observe (a fee-taking v4 hook), which is a different launch kind.

  Merged from write_foundry_tests, audit_permissions, audit_economics, audit_math and audit_flow, which all reported the same root cause. Reproduced with the attached proof (two tests, both fail on this code with 0 != 30000000000000000000) and against the real PoolManager with .imd/reads/proofs/Proof_0d1a628adc2c.t.sol (fails: a 1,000 MAD sell paid no sell tax).

  The tree's own tests test/MADToken.t.sol test_sellToPoolArrivesWhole and test/MADTokenV4.t.sol:158 test_sellOfWholeBoughtBalanceSettlesAndIsUntaxed assert the 0 as intended.

  whole finding

  State: vm.prank(FACTORY=0xFAC7); token = new MADToken(FACTORY, POOL_MANAGER=0x900C); FACTORY transfers 1000e18 MAD to ALICE (plain transfer, no tax).

  Call: vm.prank(ALICE); token.transfer(POOL_MANAGER, 1000e18).

  Expected under the brief (3% buy/sell tax): balanceOf(TAX_WALLET) == 30e18 and the PoolManager receives 970e18 (or 1000e18 with 30e18 charged elsewhere).

  Actual: balanceOf(TAX_WALLET) == 0, balanceOf(POOL_MANAGER) == 1000e18, no BuyTaxed event.

  Same via an approved router: ALICE approves 0x5007 for 1000e18, 0x5007 calls transferFrom(ALICE, POOL_MANAGER, 1000e18): tax wallet still 0.

  Run: forge test --match-path test/scratch/Proof_9b2a28a1eb79.t.sol (both tests fail: 0 != 30000000000000000000).

  whole reproduction
  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {Test} from "forge-std/Test.sol";
  import {MADToken} from "src/MADToken.sol";
  
  /// @notice Finding: the brief specifies a 3% buy/sell tax to the tax wallet. A sell (a transfer
  /// whose recipient is the PoolManager) pays nothing. Expected after selling 1000 MAD: the tax
  /// wallet gained 30 MAD. Actual: 0.
  contract SellTaxMissingTest is Test {
      address constant TAX_WALLET = 0x1EE3ffadfE138415A2ddaedeEBe5F46616fA413d;
      address constant FACTORY = address(0xFAC7);
      address constant POOL_MANAGER = address(0x900C);
      address constant ALICE = address(0xA11CE);
  
      MADToken token;
  
      function setUp() public {
          vm.prank(FACTORY);
          token = new MADToken(FACTORY, POOL_MANAGER);
          vm.prank(FACTORY);
          token.transfer(ALICE, 1_000e18);
      }
  
      function test_sellPaysThreePercentToTaxWallet() public {
          uint256 taxBefore = token.balanceOf(TAX_WALLET);
          vm.prank(ALICE);
          token.transfer(POOL_MANAGER, 1_000e18);
          assertEq(token.balanceOf(TAX_WALLET) - taxBefore, 30e18, "a 1000 MAD sell paid no 3% tax");
      }
  
      function test_sellViaTransferFromPaysThreePercentToTaxWallet() public {
          address router = address(0x5007);
          vm.prank(ALICE);
          token.approve(router, 1_000e18);
          uint256 taxBefore = token.balanceOf(TAX_WALLET);
          vm.prank(router);
          token.transferFrom(ALICE, POOL_MANAGER, 1_000e18);
          assertEq(token.balanceOf(TAX_WALLET) - taxBefore, 30e18, "a 1000 MAD sell paid no 3% tax");
      }
  }

  whole proof

• mediumBuy tax is bypassed by settling the MAD swap output as Uniswap v4 ERC-6909 claims inside the PoolManagersrc/MADToken.sol:83

  The only tax the token charges is on an ERC-20 transfer whose sender is the PoolManager. Uniswap v4 does not require a buyer to take the output as an ERC-20: inside the same unlock the trader may call PoolManager.mint(to, currency.toId(), amount) and keep the bought MAD as an ERC-6909 claim balance inside the PoolManager; MAD's ERC-20 balances never move, _update never runs with from == POOL_MANAGER, no BuyTaxed event is emitted and the tax wallet receives nothing.

  A later sell is paid with PoolManager.burn(from, id, amount), again with no ERC-20 transfer, and claims are freely transferable between accounts with the PoolManager's ERC-6909 transfer/transferFrom. Multi-hop v4 routes where MAD is an intermediate currency never leave the PoolManager either.

  So any unprivileged caller with a custom router (every arbitrage or MEV bot) can buy, hold, transfer and sell MAD through the launch pool paying 0% in both directions, while an ordinary wallet using take pays 3%; a liquidity provider can likewise remove the MAD leg of a position as claims untaxed. The 3% is only paid by whoever finally converts a claim back to ERC-20 MAD. The README and the NatSpec (lines 15-18) do not mention this path.

  The token cannot observe ERC-6909 accounting, so there is no fix inside _update; closing it needs a tax charged on the swap delta (a v4 hook), which is a different launch kind, and the launch pool's hook slot is taken by the factory's initialization guard. This is a scope decision for the requester: accept an avoidable buy tax and document that it applies only to ERC-20 withdrawals from the PoolManager, or change the fee design.

  Severity is medium, not high: the party shorted is the tax wallet's fee revenue, no holder's funds are lost and nothing is paid to a wrong party, and it only arises for traders who use claim settlement. Merged from write_foundry_tests, audit_permissions (reported high), audit_economics, audit_math and audit_flow.

  Note: the audit_math claim that the Universal Router exposes claim settlement as a flag was not verified; the bypass needs a custom unlock callback, which the proof supplies.

  whole finding

  State: real v4 PoolManager (new PoolManager(this)), MADToken(factory=this, manager), MAD/PAIR pool at sqrtPrice 2^96 (1:1), fee 12500, tick spacing 60, no hook, LiquidityRouter adds 1_000_000e18 liquidity in [-600, 600] paying both legs by sync/transfer/settle.

  ClaimsTrader holds 1000e18 PAIR.

  Call 1 (inside unlock): swap(PAIR->MAD, exact input 100e18) returns a MAD delta of 98740249400371713293; settle PAIR by sync/transfer/settle; settle the MAD delta with manager.mint(trader, Currency.wrap(MAD).toId(), 98740249400371713293).

  Actual: manager.balanceOf(trader, madId) == 98740249400371713293, token.balanceOf(manager) unchanged, token.balanceOf(TAX_WALLET) == 0.

  Expected under the README's own guarantee ('Buy: 97% to trader, 3% to tax wallet'): TAX_WALLET += 2962207482011151398.

  Call 2: swap(MAD->PAIR, exact input 98740249400371713293) settled with manager.burn(trader, madId, amount), PAIR taken: trader's PAIR balance rises, claims are 0, TAX_WALLET still 0.

  Compare test/MADTokenV4.t.sol:142 test_buyPaysThreePercentOfTheGrossOutput where the identical swap settled with take pays 2962207482011151398.

  Run: forge test --match-path test/scratch/Proof_31bc87a4bcfb.t.sol (fails: 'buy settled as ERC-6909 claims paid no buy tax: 0 != 2962207482011151398').

  Exact-output variant: .imd/reads/proofs/Proof_6c22e85c2425.t.sol fails with 0 != 3000000000000000000.

  whole reproduction
  proof · a Foundry test the fix has to pass

  // SPDX-License-Identifier: MIT
  pragma solidity 0.8.26;
  
  import {Test} from "forge-std/Test.sol";
  import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
  import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
  import {PoolManager} from "v4-core/src/PoolManager.sol";
  import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
  import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
  import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
  import {PoolKey} from "v4-core/src/types/PoolKey.sol";
  import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
  import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
  import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
  import {TickMath} from "v4-core/src/libraries/TickMath.sol";
  import {MADToken} from "src/MADToken.sol";
  
  /// @notice The paired currency: a plain 18-decimal ERC-20 standing in for FWA.
  contract PairToken is ERC20 {
      constructor() ERC20("Pair", "PAIR") {}
  
      function mint(address to, uint256 amount) external {
          _mint(to, amount);
      }
  }
  
  /// @notice Seeds a two-sided position the ordinary way (sync / transfer / settle for both legs).
  contract LiquidityRouter is IUnlockCallback {
      IPoolManager immutable manager;
  
      constructor(IPoolManager manager_) {
          manager = manager_;
      }
  
      function modify(PoolKey calldata key, ModifyLiquidityParams calldata params) external returns (BalanceDelta) {
          return abi.decode(manager.unlock(abi.encode(key, params)), (BalanceDelta));
      }
  
      function unlockCallback(bytes calldata data) external returns (bytes memory) {
          require(msg.sender == address(manager), "not the pool manager");
          (PoolKey memory key, ModifyLiquidityParams memory params) = abi.decode(data, (PoolKey, ModifyLiquidityParams));
          (BalanceDelta delta,) = manager.modifyLiquidity(key, params, "");
          _pay(key.currency0, delta.amount0());
          _pay(key.currency1, delta.amount1());
          return abi.encode(delta);
      }
  
      function _pay(Currency currency, int128 delta) internal {
          require(delta <= 0, "seed only pays");
          if (delta < 0) {
              manager.sync(currency);
              IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(uint128(-delta)));
              manager.settle();
          }
      }
  }
  
  /// @notice A trader that keeps its MAD inside the PoolManager as ERC-6909 claims. Buying mints
  /// claims instead of taking the ERC-20 out; selling burns claims instead of transferring in.
  /// Neither step moves MAD through `MADToken._update`, so the 3% buy tax is never charged.
  contract ClaimsTrader is IUnlockCallback {
      using CurrencyLibrary for Currency;
  
      IPoolManager immutable manager;
      PoolKey key;
      Currency mad;
  
      constructor(IPoolManager manager_, PoolKey memory key_, Currency mad_) {
          manager = manager_;
          key = key_;
          mad = mad_;
      }
  
      function swap(bool zeroForOne, int256 amountSpecified) external returns (BalanceDelta) {
          return abi.decode(manager.unlock(abi.encode(zeroForOne, amountSpecified)), (BalanceDelta));
      }
  
      function unlockCallback(bytes calldata data) external returns (bytes memory) {
          require(msg.sender == address(manager), "not the pool manager");
          (bool zeroForOne, int256 amountSpecified) = abi.decode(data, (bool, int256));
          uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
          BalanceDelta delta = manager.swap(key, SwapParams(zeroForOne, amountSpecified, limit), "");
          _settle(key.currency0, delta.amount0());
          _settle(key.currency1, delta.amount1());
          return abi.encode(delta);
      }
  
      function _settle(Currency currency, int128 delta) internal {
          if (delta == 0) return;
          bool isMad = Currency.unwrap(currency) == Currency.unwrap(mad);
          if (delta > 0) {
              uint256 amount = uint256(uint128(delta));
              if (isMad) {
                  // Buy: keep the MAD inside the PoolManager as a claim. No ERC-20 transfer happens.
                  manager.mint(address(this), currency.toId(), amount);
              } else {
                  manager.take(currency, address(this), amount);
              }
          } else {
              uint256 amount = uint256(uint128(-delta));
              if (isMad) {
                  // Sell: pay with claims. No ERC-20 transfer happens.
                  manager.burn(address(this), currency.toId(), amount);
              } else {
                  manager.sync(currency);
                  IERC20(Currency.unwrap(currency)).transfer(address(manager), amount);
                  manager.settle();
              }
          }
      }
  }
  
  /// @notice Fails on the current MADToken: a buy settled as ERC-6909 claims pays no tax, and the
  /// claims can be sold back (burned) or transferred without ever paying it either.
  contract MADClaimsBypassTest is Test {
      using CurrencyLibrary for Currency;
  
      address constant TAX_WALLET = 0x1EE3ffadfE138415A2ddaedeEBe5F46616fA413d;
      uint24 constant POOL_FEE = 12_500;
      int24 constant TICK_SPACING = 60;
      uint160 constant ONE_TO_ONE = 79_228_162_514_264_337_593_543_950_336;
  
      PoolManager manager;
      MADToken token;
      PairToken pair;
      LiquidityRouter lp;
      ClaimsTrader trader;
      PoolKey key;
      bool tokenIsZero;
  
      function setUp() public {
          manager = new PoolManager(address(this));
          pair = new PairToken();
          // This test contract plays the factory: it deploys the token and holds the supply.
          token = new MADToken(address(this), address(manager));
          lp = new LiquidityRouter(manager);
  
          tokenIsZero = address(token) < address(pair);
          (Currency c0, Currency c1) = tokenIsZero
              ? (Currency.wrap(address(token)), Currency.wrap(address(pair)))
              : (Currency.wrap(address(pair)), Currency.wrap(address(token)));
          key = PoolKey(c0, c1, POOL_FEE, TICK_SPACING, IHooks(address(0)));
          manager.initialize(key, ONE_TO_ONE);
  
          token.transfer(address(lp), 10_000_000e18);
          pair.mint(address(lp), 10_000_000e18);
          lp.modify(key, ModifyLiquidityParams(-600, 600, 1_000_000e18, bytes32(0)));
  
          trader = new ClaimsTrader(manager, key, Currency.wrap(address(token)));
      }
  
      function _tokenDelta(BalanceDelta delta) internal view returns (int128) {
          return tokenIsZero ? delta.amount0() : delta.amount1();
      }
  
      function test_buyAsClaimsPaysNoTax() public {
          pair.mint(address(trader), 1_000e18);
          uint256 poolBefore = token.balanceOf(address(manager));
          uint256 madId = Currency.wrap(address(token)).toId();
  
          // Buy: 100 PAIR in, MAD out, kept as ERC-6909 claims.
          BalanceDelta delta = trader.swap(!tokenIsZero, -100e18);
          uint256 gross = uint256(uint128(_tokenDelta(delta)));
          assertGt(gross, 0, "no MAD came out of the swap");
          assertEq(manager.balanceOf(address(trader), madId), gross, "trader did not get full gross as claims");
          assertEq(token.balanceOf(address(manager)), poolBefore, "no ERC-20 left the PoolManager");
  
          // Sell everything back by burning the claims: still no ERC-20 transfer.
          uint256 pairBefore = pair.balanceOf(address(trader));
          trader.swap(tokenIsZero, -int256(gross));
          assertEq(manager.balanceOf(address(trader), madId), 0, "claims not fully burned");
          assertGt(pair.balanceOf(address(trader)), pairBefore, "no PAIR came back from the sell");
  
          // The contract's stated guarantee: every buy from the pool pays 3% of the gross to the tax wallet.
          // Here a full buy-then-sell round trip through the pool paid nothing.
          uint256 expectedTax = (gross * token.TAX_BPS()) / token.BPS_DENOMINATOR();
          assertEq(token.balanceOf(TAX_WALLET), expectedTax, "buy settled as ERC-6909 claims paid no buy tax");
      }
  }

  whole proof

• lowEvery ERC-20 exit from the PoolManager is taxed as a buy, including liquidity withdrawal and fee collectionsrc/MADToken.sol:83

  'Sender is the PoolManager' is used as the definition of a buy, but the PoolManager also pays out the MAD leg of modifyLiquidity with a negative liquidityDelta, accrued MAD swap fees collected by a position owner (including an add to an existing position whose accrued fees exceed the deposit, where the net delta pays out), and a settlement surplus taken back, all through take().

  Each of these is charged 3% to the tax wallet although no purchase occurred, while adding liquidity is untaxed, so an outside LP that deposits X MAD and withdraws it receives 0.97X. Combined with finding 2, an LP settling with mint (claims) pays nothing, so the cost falls only on LPs using standard tooling (PositionManager TAKE_PAIR).

  The launch's own seeded position is unaffected only while it is withdrawn to an exempt address (the factory); if the factory ever withdraws the 800,000,000 MAD seed position to a non-exempt address such as the requester's wallet, 3% of the remaining MAD leg goes to the tax wallet. The README discloses the LP case under 'Side effects to be aware of' and the tree's test test/MADTokenV4.t.sol:183 test_removingLiquidityIsTreatedAsABuyOfTheTokenLeg asserts it as intended.

  No token-level fix exists without a venue signal (the token cannot tell a take() after swap from a take() after modifyLiquidity); reported low so the requester confirms that third-party LPs forfeiting 3% of their own principal is accepted. Merged from write_foundry_tests, audit_permissions, audit_economics, audit_math and audit_flow.

  whole finding

  State: test/MADTokenV4.t.sol setUp (real PoolManager, MAD/PAIR at 1:1, LiquidityRouter lp holds a position of liquidity 1_000_000e18 in [-600, 600], TAX_WALLET balance 0).

  Call: lp.modify(key, ModifyLiquidityParams(-600, 600, -1_000_000e18, bytes32(0))), which takes both legs to lp.

  Let G be the positive MAD leg of the returned BalanceDelta.

  Expected for a withdrawal of one's own liquidity: lp's MAD balance rises by G and the tax wallet is unchanged.

  Actual: lp's MAD balance rises by G - G300/10000 and balanceOf(TAX_WALLET) == G300/10000.

  This is exactly what the passing tree test test_removingLiquidityIsTreatedAsABuyOfTheTokenLeg asserts (run with FOUNDRY_FUZZ_SEED as in the README; 60 tests pass). audit_flow measured a concrete instance: deposit of 2955301087913716968083 MAD, withdrawal delivered 2866642055276305459040 to the LP and 88659032637411509042 to the tax wallet.

  whole reproduction

• infoTax rounds down: buys below 34 wei pay nothing and each buy under-collects by up to 1 weisrc/MADToken.sol:96

  _taxOf truncates toward the buyer: a gross of 1..33 wei pays 0 tax (33*300/10000 == 0) and every buy loses the fractional wei, so split buys always pay at most what one buy of the same total pays. The auditor checklist prefers fees that round toward the fee recipient.

  Impact is dust at 18 decimals (33 wei of MAD is far below swap gas), there is no compounding, and no overflow is reachable in _update (gross <= 1e27). previewBuy(buyer, g) reverts with Panic(0x11) for g > type(uint256).max / 300 instead of returning, which is harmless for a view. The README states the 34-wei threshold. Minimal change if the fee-favouring direction is wanted: tax = (grossAmount * TAX_BPS + BPS_DENOMINATOR - 1) / BPS_DENOMINATOR, and update the README sentence.

  From audit_math; kept as information, not a defect that reopens the work.

  State: FACTORY=0xFAC7 deploys the token and transfers the supply to POOL_MANAGER=0x900C.

  Calls from POOL_MANAGER: transfer(ALICE, 33) repeated 100 times -> ALICE 3300, TAX_WALLET 0, no BuyTaxed event; transfer(BOB, 3300) -> BOB 3201, TAX_WALLET 99; transfer(ALICE, 66) -> tax 1 (true 1.98), ALICE +65. previewBuy(ALICE, type(uint256).max) reverts with arithmetic overflow.

  Expected under round-up fees: 33 wei -> 1 wei tax, 66 wei -> 2 wei tax.

• infoRouters' minimum-output checks and exact-output swaps see the gross amount; the buyer receives 3% lesssrc/MADToken.sol:89

  v4 routers enforce amountOutMinimum against the swap's BalanceDelta, which is the gross amount debited from the PoolManager; the recipient's actual credit is value - tax. A buyer who sets amountOutMinimum = X can receive 0.97X without the router reverting, and an exact-output swap for X delivers 0.97X. The README discloses this ('Routers that check output on the swap delta see the gross amount') and it is inherent to a transfer-level tax; there is no on-chain fix in the token.

  Recorded so front-ends quote MAD buys net of 3%. From audit_math.

  State: test/MADTokenV4.t.sol setUp (real PoolManager, MAD/PAIR at 1:1).

  Call: trader.swap(key, !tokenIsZero, 100e18) (exact output of 100e18 MAD, settled with take).

  Actual: the MAD leg of the BalanceDelta is +100e18 (what a router compares against amountOutMinimum), token.balanceOf(trader) == 97e18, balanceOf(TAX_WALLET) == 3e18.

  Expected by a router's slippage check: the buyer holds 100e18.

  Asserted by the passing tree test test/MADTokenV4.t.sol:175 test_exactOutputBuyDeliversNetOfTax.

Failed in the task.