Implement Claims accounting as minimal balance

.forge-snapshots/before swap hook, already cached dynamic fee.snap

@@ -1 +1 @@
-85384
+85229

.forge-snapshots/cached dynamic fee, no hooks.snap

@@ -1 +1 @@
-82539
+82413

.forge-snapshots/donate gas with 1 token.snap

@@ -1 +1 @@
-95961
+95883

.forge-snapshots/donate gas with 2 tokens.snap

@@ -1 +1 @@
-153292
+153248

.forge-snapshots/erc20 collect protocol fees.snap

@@ -0,0 +1 @@
+25011

.forge-snapshots/gas overhead of no-op lock.snap

@@ -1 +1 @@
-58562
+58439

.forge-snapshots/initialize.snap

@@ -1 +1 @@
-38123
+38079

.forge-snapshots/mint with empty hook.snap

@@ -1 +1 @@
-307130
+307014

.forge-snapshots/mint with native token.snap

@@ -1 +1 @@
-275102
+275044

.forge-snapshots/mint.snap

@@ -1 +1 @@
-293738
+293680

.forge-snapshots/native collect protocol fees.snap

@@ -0,0 +1 @@
+36677

.forge-snapshots/poolManager bytecode size.snap

@@ -1 +1 @@
-29853
+24460

.forge-snapshots/simple swap.snap

@@ -1 +1 @@
-49771
+49645

.forge-snapshots/swap against liquidity with native token.snap

@@ -1 +1 @@
-125033
+124919

.forge-snapshots/swap against liquidity.snap

@@ -1 +1 @@
-109721
+109607

.forge-snapshots/swap burn claim for input.snap

@@ -0,0 +1 @@
+126321

.forge-snapshots/swap mint output as claim.snap

@@ -0,0 +1 @@
+166331

.forge-snapshots/swap with dynamic fee.snap

@@ -1 +1 @@
-84493
+84338

.forge-snapshots/swap with hooks.snap

@@ -1 +1 @@
-49742
+49616

.forge-snapshots/swap with native.snap

@@ -1 +1 @@
-49771
+49645

.forge-snapshots/update dynamic fee in before swap.snap

@@ -1 +1 @@
-91231
+91054

contracts/Claims.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.20;
+
+import {Currency, CurrencyLibrary} from "./types/Currency.sol";
+import {IClaims} from "./interfaces/IClaims.sol";
+
+/// An intentionally barebones balance mapping only supporting mint/burn/transfer
+contract Claims is IClaims {
+    using CurrencyLibrary for Currency;
+
+    // Mapping from Currency id to account balances
+    mapping(uint256 => mapping(address => uint256)) public balances;
+
+    /// @inheritdoc IClaims
+    function balanceOf(address account, Currency currency) public view returns (uint256) {
+        return balances[currency.toId()][account];
+    }
+
+    /// @inheritdoc IClaims
+    function transfer(address to, Currency currency, uint256 amount) public {
+        if (to == address(this)) revert InvalidAddress();
+
+        uint256 id = currency.toId();
+        if (amount > balances[id][msg.sender]) revert InsufficientBalance();
+        unchecked {
+            balances[id][msg.sender] -= amount;
+        }
+        balances[id][to] += amount;
+        emit Transfer(msg.sender, to, id, amount);
+    }
+
+    /// @notice Mint `amount` of currency `id` to `to`
+    /// @param to The address to mint to
+    /// @param id The id to mint
+    /// @param amount The amount to mint
+    function _mint(address to, uint256 id, uint256 amount) internal {
+        balances[id][to] += amount;
+        emit Mint(to, id, amount);
+    }
+
+    /// @notice Burn `amount` of currency `id` from `msg.sender`
+    /// @param id The id of the currency to burn
+    /// @param amount The amount to burn
+    /// @dev Will revert if the sender does not have enough balance
+    function _burn(uint256 id, uint256 amount) internal {
+        if (amount > balances[id][msg.sender]) revert InsufficientBalance();
+        unchecked {
+            balances[id][msg.sender] -= amount;
+        }
+        emit Burn(msg.sender, id, amount);
+    }
+}

contracts/PoolManager.sol

@@ -17,13 +17,12 @@ import {IHookFeeManager} from "./interfaces/IHookFeeManager.sol";
 import {IPoolManager} from "./interfaces/IPoolManager.sol";
 import {ILockCallback} from "./interfaces/callback/ILockCallback.sol";
 import {Fees} from "./Fees.sol";
-import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
-import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+import {Claims} from "./Claims.sol";
 import {PoolId, PoolIdLibrary} from "./types/PoolId.sol";
 import {BalanceDelta} from "./types/BalanceDelta.sol";
 
 /// @notice Holds the state for all pools
-contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Receiver {
+contract PoolManager is IPoolManager, Fees, NoDelegateCall, Claims {
     using PoolIdLibrary for PoolKey;
     using SafeCast for *;
     using Pool for *;
@@ -51,7 +50,7 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
 
     mapping(PoolId id => Pool.State) public pools;
 
-    constructor(uint256 controllerGasLimit) Fees(controllerGasLimit) ERC1155("") {}
+    constructor(uint256 controllerGasLimit) Fees(controllerGasLimit) {}
 
     function _getPool(PoolKey memory key) private view returns (Pool.State storage) {
         return pools[key.toId()];
@@ -323,12 +322,6 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
         currency.transfer(to, amount);
     }
 
-    /// @inheritdoc IPoolManager
-    function mint(Currency currency, address to, uint256 amount) external override noDelegateCall onlyByLocker {
-        _accountDelta(currency, amount.toInt128());
-        _mint(to, currency.toId(), amount, "");
-    }
-
     /// @inheritdoc IPoolManager
     function settle(Currency currency) external payable override noDelegateCall onlyByLocker returns (uint256 paid) {
         uint256 reservesBefore = reservesOf[currency];
@@ -338,26 +331,16 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC1155, IERC1155Rec
         _accountDelta(currency, -(paid.toInt128()));
     }
 
-    function _burnAndAccount(Currency currency, uint256 amount) internal {
-        _burn(address(this), currency.toId(), amount);
-        _accountDelta(currency, -(amount.toInt128()));
-    }
-
-    function onERC1155Received(address, address, uint256 id, uint256 value, bytes calldata) external returns (bytes4) {
-        if (msg.sender != address(this)) revert NotPoolManagerToken();
-        _burnAndAccount(CurrencyLibrary.fromId(id), value);
-        return IERC1155Receiver.onERC1155Received.selector;
+    /// @inheritdoc IPoolManager
+    function mint(Currency currency, address to, uint256 amount) external noDelegateCall onlyByLocker {
+        _accountDelta(currency, amount.toInt128());
+        _mint(to, currency.toId(), amount);
     }
 
-    function onERC1155BatchReceived(address, address, uint256[] calldata ids, uint256[] calldata values, bytes calldata)
-        external
-        returns (bytes4)
-    {
-        if (msg.sender != address(this)) revert NotPoolManagerToken();
-        for (uint256 i; i < ids.length; i++) {
-            _burnAndAccount(CurrencyLibrary.fromId(ids[i]), values[i]);
-        }
-        return IERC1155Receiver.onERC1155BatchReceived.selector;
+    /// @inheritdoc IPoolManager
+    function burn(Currency currency, uint256 amount) external noDelegateCall onlyByLocker {
+        _accountDelta(currency, -(amount.toInt128()));
+        _burn(currency.toId(), amount);
     }
 
     function setProtocolFees(PoolKey memory key) external {

contracts/interfaces/IClaims.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Currency} from "../types/Currency.sol";
+
+interface IClaims {
+    error InsufficientBalance();
+    error InvalidAddress();
+
+    /// @notice Get the balance of `account` for `currency`
+    /// @param account The account to get the balance of
+    /// @param currency The currency to get the balance of
+    function balanceOf(address account, Currency currency) external returns (uint256);
+
+    /// @notice Transfer `amount` of `currency` from sender to `to`
+    /// @param to The address to transfer to
+    /// @param currency The currency to transfer
+    /// @param amount The amount to transfer
+    /// @dev Will revert if the sender does not have enough balance
+    function transfer(address to, Currency currency, uint256 amount) external;
+
+    event Mint(address indexed to, uint256 indexed id, uint256 amount);
+    event Burn(address indexed from, uint256 indexed id, uint256 amount);
+    event Transfer(address indexed from, address indexed to, uint256 indexed id, uint256 amount);
+}

contracts/interfaces/IPoolManager.sol

@@ -4,14 +4,14 @@ pragma solidity ^0.8.20;
 import {Currency} from "../types/Currency.sol";
 import {PoolKey} from "../types/PoolKey.sol";
 import {Pool} from "../libraries/Pool.sol";
-import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
 import {IHooks} from "./IHooks.sol";
 import {IFees} from "./IFees.sol";
+import {IClaims} from "./IClaims.sol";
 import {BalanceDelta} from "../types/BalanceDelta.sol";
 import {PoolId} from "../types/PoolId.sol";
 import {Position} from "../libraries/Position.sol";
 
-interface IPoolManager is IFees, IERC1155 {
+interface IPoolManager is IFees, IClaims {
     /// @notice Thrown when currencies touched has exceeded max of 256
     error MaxCurrenciesTouched();
 
@@ -176,9 +176,12 @@ interface IPoolManager is IFees, IERC1155 {
     /// @dev Can also be used as a mechanism for _free_ flash loans
     function take(Currency currency, address to, uint256 amount) external;
 
-    /// @notice Called by the user to move value into ERC1155 balance
+    /// @notice Called by the user to move value into Claims balance
     function mint(Currency token, address to, uint256 amount) external;
 
+    /// @notice Called by the user to redeem their Claims balance
+    function burn(Currency token, uint256 amount) external;
+
     /// @notice Called by the user to pay what is owed
     function settle(Currency token) external payable returns (uint256 paid);
 

contracts/test/MockClaims.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.20;
+
+import {Test} from "forge-std/Test.sol";
+import {Claims} from "../Claims.sol";
+import {IClaims} from "../interfaces/IClaims.sol";
+import {CurrencyLibrary, Currency} from "../types/Currency.sol";
+
+contract MockClaims is Claims {
+    using CurrencyLibrary for Currency;
+
+    function mint(address to, Currency currency, uint256 amount) public {
+        _mint(to, currency.toId(), amount);
+    }
+
+    function burn(Currency currency, uint256 amount) public {
+        _burn(currency.toId(), amount);
+    }
+}

contracts/test/PoolSwapTest.sol

@@ -3,7 +3,6 @@ pragma solidity ^0.8.20;
 
 import {CurrencyLibrary, Currency} from "../types/Currency.sol";
 import {IERC20Minimal} from "../interfaces/external/IERC20Minimal.sol";
-
 import {ILockCallback} from "../interfaces/callback/ILockCallback.sol";
 import {IPoolManager} from "../interfaces/IPoolManager.sol";
 import {BalanceDelta} from "../types/BalanceDelta.sol";
@@ -45,6 +44,10 @@ contract PoolSwapTest is ILockCallback {
         if (ethBalance > 0) CurrencyLibrary.NATIVE.transfer(msg.sender, ethBalance);
     }
 
+    function _burnFromSelf(Currency currency, uint256 amount) internal {
+        manager.burn(currency, amount);
+    }
+
     function lockAcquired(bytes calldata rawData) external returns (bytes memory) {
         require(msg.sender == address(manager));
 
@@ -64,21 +67,14 @@ contract PoolSwapTest is ILockCallback {
                         manager.settle(data.key.currency0);
                     }
                 } else {
-                    // the received hook on this transfer will burn the tokens
-                    manager.safeTransferFrom(
-                        data.sender,
-                        address(manager),
-                        uint256(uint160(Currency.unwrap(data.key.currency0))),
-                        uint128(delta.amount0()),
-                        ""
-                    );
+                    manager.burn(data.key.currency0, uint128(delta.amount0()));
                 }
             }
             if (delta.amount1() < 0) {
                 if (data.testSettings.withdrawTokens) {
                     manager.take(data.key.currency1, data.sender, uint128(-delta.amount1()));
                 } else {
-                    manager.mint(data.key.currency1, data.sender, uint128(-delta.amount1()));
+                    manager.mint(data.key.currency1, address(this), uint128(-delta.amount1()));
                 }
             }
         } else {
@@ -93,21 +89,14 @@ contract PoolSwapTest is ILockCallback {
                         manager.settle(data.key.currency1);
                     }
                 } else {
-                    // the received hook on this transfer will burn the tokens
-                    manager.safeTransferFrom(
-                        data.sender,
-                        address(manager),
-                        uint256(uint160(Currency.unwrap(data.key.currency1))),
-                        uint128(delta.amount1()),
-                        ""
-                    );
+                    manager.burn(data.key.currency1, uint128(delta.amount1()));
                 }
             }
             if (delta.amount0() < 0) {
                 if (data.testSettings.withdrawTokens) {
                     manager.take(data.key.currency0, data.sender, uint128(-delta.amount0()));
                 } else {
-                    manager.mint(data.key.currency0, data.sender, uint128(-delta.amount0()));
+                    manager.mint(data.key.currency0, address(this), uint128(-delta.amount0()));
                 }
             }
         }