fix: Add ERC6909 support

.forge-snapshots/addLiquidity with empty hook.snap

@@ -1 +1 @@
-323249
+323277

.forge-snapshots/addLiquidity with native token.snap

@@ -1 +1 @@
-200141
+200111

.forge-snapshots/addLiquidity.snap

@@ -1 +1 @@
-200109
+200079

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

@@ -1 +1 @@
-194300
+194367

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

@@ -1 +1 @@
-146667
+146705

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

@@ -1 +1 @@
-137771
+137750

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

@@ -1 +1 @@
-185216
+185163

.forge-snapshots/erc20 collect protocol fees.snap

@@ -1 +1 @@
-27033
+27001

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

@@ -1 +1 @@
-15224
+15223

.forge-snapshots/initialize.snap

@@ -1 +1 @@
-74200
+74274

.forge-snapshots/mint with empty hook.snap

@@ -1 +1 @@
-323262
+323262

.forge-snapshots/mint with native token.snap

@@ -1 +1 @@
-200100
+200100

.forge-snapshots/mint.snap

@@ -1 +1 @@
-200042
+200042

.forge-snapshots/mintWithEmptyHookEOAInitiated.snap

@@ -1 +1 @@
-255129
+255189

.forge-snapshots/modify position with noop.snap

@@ -1 +1 @@
-58013
+58076

.forge-snapshots/native collect protocol fees.snap

@@ -1 +1 @@
-38699
+38667

.forge-snapshots/poolManager bytecode size.snap

@@ -1 +1 @@
-23823
+25102

.forge-snapshots/removeLiquidity with empty hook.snap

@@ -1 +1 @@
-106962
+106952

.forge-snapshots/removeLiquidity with native token.snap

@@ -1 +1 @@
-208322
+208312

.forge-snapshots/removeLiquidity.snap

@@ -1 +1 @@
-204612
+204602

.forge-snapshots/simple swap with native.snap

@@ -1 +1 @@
-195638
+195676

.forge-snapshots/simple swap.snap

@@ -1 +1 @@
-204206
+204244

.forge-snapshots/simpleSwapEOAInitiated.snap

@@ -1 +1 @@
-173543
+174149

.forge-snapshots/simpleSwapNativeEOAInitiated.snap

@@ -1 +1 @@
-172131
+172798

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

@@ -1 +1 @@
-126266
+126304

.forge-snapshots/swap against liquidity.snap

@@ -1 +1 @@
-113757
+113795

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

@@ -0,0 +1 @@
+133995

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

@@ -1 +1 @@
-132930
+132930

.forge-snapshots/swap burn native 6909 for input.snap

@@ -0,0 +1 @@
+129926

.forge-snapshots/swap mint native output as 6909.snap

@@ -0,0 +1 @@
+198205

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

@@ -0,0 +1 @@
+215075

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

@@ -1 +1 @@
-216399
+216399

.forge-snapshots/swap with dynamic fee.snap

@@ -1 +1 @@
-193401
+193468

.forge-snapshots/swap with hooks.snap

@@ -1 +1 @@
-113735
+113773

.forge-snapshots/swap with noop.snap

@@ -1 +1 @@
-51304
+51425

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

@@ -1 +1 @@
-200144
+200232

.gitmodules

@@ -4,10 +4,10 @@
 [submodule "lib/forge-gas-snapshot"]
 	path = lib/forge-gas-snapshot
 	url = https://github.com/marktoda/forge-gas-snapshot
-[submodule "lib/solmate"]
-	path = lib/solmate
-	url = https://github.com/transmissions11/solmate
 [submodule "lib/openzeppelin-contracts"]
 	path = lib/openzeppelin-contracts
 	url = https://github.com/OpenZeppelin/openzeppelin-contracts
 	tag = v4.4.2
+[submodule "lib/solmate"]
+	path = lib/solmate
+	url = https://github.com/transmissions11/solmate

src/ERC6909.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {IERC6909Claims} from "./interfaces/external/IERC6909Claims.sol";
+
+/// @notice Minimalist and gas efficient standard ERC6909 implementation.
+/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC6909.sol)
+/// @dev Copied from the commit at 4b47a19038b798b4a33d9749d25e570443520647
+/// @dev This contract has been modified from the implementation at the above link.
+abstract contract ERC6909 is IERC6909Claims {
+    /*//////////////////////////////////////////////////////////////
+                                 EVENTS
+    //////////////////////////////////////////////////////////////*/
+
+    event OperatorSet(address indexed owner, address indexed operator, bool approved);
+
+    event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount);
+
+    event Transfer(address caller, address indexed from, address indexed to, uint256 indexed id, uint256 amount);
+
+    /*//////////////////////////////////////////////////////////////
+                             ERC6909 STORAGE
+    //////////////////////////////////////////////////////////////*/
+
+    mapping(address => mapping(address => bool)) public isOperator;
+
+    mapping(address => mapping(uint256 => uint256)) public balanceOf;
+
+    mapping(address => mapping(address => mapping(uint256 => uint256))) public allowance;
+
+    /*//////////////////////////////////////////////////////////////
+                              ERC6909 LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function transfer(address receiver, uint256 id, uint256 amount) public virtual returns (bool) {
+        balanceOf[msg.sender][id] -= amount;
+
+        balanceOf[receiver][id] += amount;
+
+        emit Transfer(msg.sender, msg.sender, receiver, id, amount);
+
+        return true;
+    }
+
+    function transferFrom(address sender, address receiver, uint256 id, uint256 amount) public virtual returns (bool) {
+        if (msg.sender != sender && !isOperator[sender][msg.sender]) {
+            uint256 allowed = allowance[sender][msg.sender][id];
+            if (allowed != type(uint256).max) allowance[sender][msg.sender][id] = allowed - amount;
+        }
+
+        balanceOf[sender][id] -= amount;
+
+        balanceOf[receiver][id] += amount;
+
+        emit Transfer(msg.sender, sender, receiver, id, amount);
+
+        return true;
+    }
+
+    function approve(address spender, uint256 id, uint256 amount) public virtual returns (bool) {
+        allowance[msg.sender][spender][id] = amount;
+
+        emit Approval(msg.sender, spender, id, amount);
+
+        return true;
+    }
+
+    function setOperator(address operator, bool approved) public virtual returns (bool) {
+        isOperator[msg.sender][operator] = approved;
+
+        emit OperatorSet(msg.sender, operator, approved);
+
+        return true;
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                              ERC165 LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
+        return interfaceId == 0x01ffc9a7 // ERC165 Interface ID for ERC165
+            || interfaceId == 0x0f632fb3; // ERC165 Interface ID for ERC6909
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                        INTERNAL MINT/BURN LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    function _mint(address receiver, uint256 id, uint256 amount) internal virtual {
+        balanceOf[receiver][id] += amount;
+
+        emit Transfer(msg.sender, address(0), receiver, id, amount);
+    }
+
+    function _burn(address sender, uint256 id, uint256 amount) internal virtual {
+        balanceOf[sender][id] -= amount;
+
+        emit Transfer(msg.sender, sender, address(0), id, amount);
+    }
+}

src/ERC6909Claims.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import {ERC6909} from "./ERC6909.sol";
+
+/// @notice ERC6909Claims inherits ERC6909 and implements an internal burnFrom function
+abstract contract ERC6909Claims is ERC6909 {
+    /// @notice Burn `amount` tokens of token type `id` from `from`.
+    /// @dev if sender is not `from` they must be an operator or have sufficient allowance.
+    /// @param from The address to burn tokens from.
+    /// @param id The currency to burn.
+    /// @param amount The amount to burn.
+    function _burnFrom(address from, uint256 id, uint256 amount) internal {
+        address sender = msg.sender;
+        if (from != sender && !isOperator[from][sender]) {
+            uint256 senderAllowance = allowance[from][sender][id];
+            if (senderAllowance != type(uint256).max) {
+                allowance[from][sender][id] = senderAllowance - amount;
+            }
+        }
+        _burn(from, id, amount);
+    }
+}

src/PoolManager.sol

@@ -16,14 +16,14 @@ import {IDynamicFeeManager} from "./interfaces/IDynamicFeeManager.sol";
 import {IPoolManager} from "./interfaces/IPoolManager.sol";
 import {ILockCallback} from "./interfaces/callback/ILockCallback.sol";
 import {Fees} from "./Fees.sol";
-import {Claims} from "./Claims.sol";
+import {ERC6909Claims} from "./ERC6909Claims.sol";
 import {PoolId, PoolIdLibrary} from "./types/PoolId.sol";
 import {BalanceDelta, BalanceDeltaLibrary} from "./types/BalanceDelta.sol";
 import {Lockers} from "./libraries/Lockers.sol";
 import {PoolGetters} from "./libraries/PoolGetters.sol";
 
 /// @notice Holds the state for all pools
-contract PoolManager is IPoolManager, Fees, NoDelegateCall, Claims {
+contract PoolManager is IPoolManager, Fees, NoDelegateCall, ERC6909Claims {
     using PoolIdLibrary for PoolKey;
     using SafeCast for *;
     using Pool for *;
@@ -288,15 +288,15 @@ contract PoolManager is IPoolManager, Fees, NoDelegateCall, Claims {
     }
 
     /// @inheritdoc IPoolManager
-    function mint(Currency currency, address to, uint256 amount) external noDelegateCall onlyByLocker {
-        _accountDelta(currency, amount.toInt128());
-        _mint(to, currency, amount);
+    function mint(address to, uint256 id, uint256 amount) external override noDelegateCall onlyByLocker {
+        _accountDelta(CurrencyLibrary.fromId(id), amount.toInt128());
+        _mint(to, id, amount);
     }
 
     /// @inheritdoc IPoolManager
-    function burn(Currency currency, uint256 amount) external noDelegateCall onlyByLocker {
-        _accountDelta(currency, -(amount.toInt128()));
-        _burn(currency, amount);
+    function burn(address from, uint256 id, uint256 amount) external override noDelegateCall onlyByLocker {
+        _accountDelta(CurrencyLibrary.fromId(id), -(amount.toInt128()));
+        _burnFrom(from, id, amount);
     }
 
     function setProtocolFee(PoolKey memory key) external {

src/interfaces/IPoolManager.sol

@@ -5,13 +5,14 @@ import {Currency} from "../types/Currency.sol";
 import {PoolKey} from "../types/PoolKey.sol";
 import {Pool} from "../libraries/Pool.sol";
 import {IHooks} from "./IHooks.sol";
+import {IERC6909Claims} from "./external/IERC6909Claims.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, IClaims {
+interface IPoolManager is IFees, IERC6909Claims {
     /// @notice Thrown when currencies touched has exceeded max of 256
     error MaxCurrenciesTouched();
 
@@ -185,11 +186,11 @@ interface IPoolManager is IFees, IClaims {
     /// @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 Claims balance
-    function mint(Currency token, address to, uint256 amount) external;
+    /// @notice Called by the user to move value into ERC6909 balance
+    function mint(address to, uint256 id, 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 move value from ERC6909 balance
+    function burn(address from, uint256 id, uint256 amount) external;
 
     /// @notice Called by the user to pay what is owed
     function settle(Currency token) external payable returns (uint256 paid);