@zoralabs/coins 2.3.0 → 2.4.0

package/src/libs/V4Liquidity.sol

@@ -269,13 +269,14 @@ library V4Liquidity {
                 salt: 0
             });
 
-            (BalanceDelta liquidityDelta, BalanceDelta feesAccrued) = poolManager.modifyLiquidity(poolKey, params, "");
+            // callerDelta already includes fees, feesAccrued is informational only
+            (BalanceDelta callerDelta, ) = poolManager.modifyLiquidity(poolKey, params, "");
 
             burnedPositions[i] = BurnedPosition({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,
-                amount0Received: uint128(liquidityDelta.amount0() + feesAccrued.amount0()),
-                amount1Received: uint128(liquidityDelta.amount1() + feesAccrued.amount1())
+                amount0Received: uint128(callerDelta.amount0()),
+                amount1Received: uint128(callerDelta.amount1())
             });
         }
     }
@@ -315,20 +316,63 @@ library V4Liquidity {
         feeGrowthInside1DeltaX128 = feeGrowthInside1X128 - feeGrowthInside1LastX128;
     }
 
+    /// @notice Mints liquidity positions into the pool
+    /// @dev Uses a defensive balance check to prevent ERC20InsufficientBalance errors during migration.
+    /// When burning positions from an old hook, the amounts received may not exactly match what's needed
+    /// to mint the same liquidity in the new hook due to:
+    ///   1. Rounding in getLiquidityForAmounts() when converting between liquidity and token amounts
+    ///   2. Price movements between burn and mint operations
+    ///   3. Any accumulated dust from previous operations
+    /// By capping each position's liquidity at what's actually mintable with remaining balances,
+    /// we ensure the migration never reverts due to insufficient tokens.
     function mintPositions(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] memory positions) internal returns (int128 amount0, int128 amount1) {
-        ModifyLiquidityParams memory params;
         uint256 numPositions = positions.length;
 
+        // Track remaining token balances throughout minting.
+        // These balances decrease as each position consumes tokens.
+        uint256 balance0 = poolKey.currency0.balanceOf(address(this));
+        uint256 balance1 = poolKey.currency1.balanceOf(address(this));
+
+        // Cache sqrt price once for all liquidity calculations
+        (uint160 sqrtPriceX96, , , ) = StateLibrary.getSlot0(poolManager, poolKey.toId());
+
         for (uint256 i; i < numPositions; i++) {
-            params = ModifyLiquidityParams({
+            if (positions[i].liquidity == 0) {
+                continue;
+            }
+
+            // Calculate the maximum liquidity we can mint given our remaining token balances.
+            // This is the key defensive check: even if the requested liquidity would require
+            // more tokens than we have (due to rounding), we cap it at what's actually possible.
+            uint128 maxLiquidity = LiquidityAmounts.getLiquidityForAmounts(
+                sqrtPriceX96,
+                TickMath.getSqrtPriceAtTick(positions[i].tickLower),
+                TickMath.getSqrtPriceAtTick(positions[i].tickUpper),
+                balance0,
+                balance1
+            );
+
+            // Use the lesser of requested liquidity and what we can actually afford
+            uint128 liquidityToMint = positions[i].liquidity < maxLiquidity ? positions[i].liquidity : maxLiquidity;
+
+            if (liquidityToMint == 0) {
+                continue;
+            }
+
+            ModifyLiquidityParams memory params = ModifyLiquidityParams({
                 tickLower: positions[i].tickLower,
                 tickUpper: positions[i].tickUpper,
-                liquidityDelta: SafeCast.toInt256(positions[i].liquidity),
+                liquidityDelta: SafeCast.toInt256(liquidityToMint),
                 salt: 0
             });
 
             (BalanceDelta delta, ) = poolManager.modifyLiquidity(poolKey, params, "");
 
+            // Update remaining balances for next iteration.
+            // delta.amount0/1 are negative when minting (tokens flow out), so adding them decreases our balance.
+            balance0 = uint256(int256(balance0) + int256(delta.amount0()));
+            balance1 = uint256(int256(balance1) + int256(delta.amount1()));
+
             amount0 += delta.amount0();
             amount1 += delta.amount1();
         }

package/src/utils/AutoSwapper.sol

@@ -9,7 +9,7 @@ pragma solidity ^0.8.28;
 
 import {ISwapRouter} from "@zoralabs/shared-contracts/interfaces/uniswap/ISwapRouter.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {Path} from "./uniswap/Path.sol";
+import {Path} from "@zoralabs/shared-contracts/libs/UniswapV3/Path.sol";
 
 /// @title AutoSwapper
 /// @notice A contract that allows for swapping of tokens via a uniswap v3 swap router. Only works with Uniswap V3 swaps.

package/src/utils/TrustedMsgSenderProviderLookup.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ContractVersionBase} from "../version/ContractVersionBase.sol";
+import {ITrustedMsgSenderProviderLookup} from "../interfaces/ITrustedMsgSenderProviderLookup.sol";
+
+/// @title TrustedMsgSenderProviderLookup
+/// @notice Contract for ITrustedMsgSenderProviderLookup that manages trusted message senders
+/// @dev This contract allows the owner to add/remove trusted senders and provides lookup functionality
+contract TrustedMsgSenderProviderLookup is ITrustedMsgSenderProviderLookup, ContractVersionBase, Ownable2Step {
+    /// @notice Emitted when a trusted sender is added
+    /// @param sender The address that was added as trusted
+    event TrustedSenderAdded(address indexed sender);
+
+    /// @notice Emitted when a trusted sender is removed
+    /// @param sender The address that was removed from trusted
+    event TrustedSenderRemoved(address indexed sender);
+
+    /// @notice Mapping of addresses to their trusted sender status
+    mapping(address => bool) private trustedSenders;
+
+    /// @notice Constructor that initializes the contract with trusted senders and sets the owner
+    /// @param trustedMessageSenders Array of addresses to mark as trusted senders initially
+    /// @param initialOwner The address that will own this contract
+    constructor(address[] memory trustedMessageSenders, address initialOwner) Ownable(initialOwner) {
+        for (uint256 i = 0; i < trustedMessageSenders.length; i++) {
+            trustedSenders[trustedMessageSenders[i]] = true;
+            emit TrustedSenderAdded(trustedMessageSenders[i]);
+        }
+    }
+
+    /// @notice Checks if an address is a trusted message sender provider
+    /// @param sender The address to check
+    /// @return true if the sender is trusted, false otherwise
+    function isTrustedMsgSenderProvider(address sender) external view override returns (bool) {
+        return trustedSenders[sender];
+    }
+
+    /// @notice Adds multiple trusted senders in a single transaction (only callable by owner)
+    /// @param senders Array of addresses to add as trusted
+    function addTrustedMsgSenderProviders(address[] calldata senders) external onlyOwner {
+        for (uint256 i = 0; i < senders.length; i++) {
+            address sender = senders[i];
+            require(sender != address(0), "Cannot add zero address as trusted sender");
+
+            if (!trustedSenders[sender]) {
+                trustedSenders[sender] = true;
+                emit TrustedSenderAdded(sender);
+            }
+        }
+    }
+
+    /// @notice Removes multiple trusted senders in a single transaction (only callable by owner)
+    /// @param senders Array of addresses to remove from trusted
+    function removeTrustedMsgSenderProviders(address[] calldata senders) external onlyOwner {
+        for (uint256 i = 0; i < senders.length; i++) {
+            address sender = senders[i];
+
+            if (trustedSenders[sender]) {
+                trustedSenders[sender] = false;
+                emit TrustedSenderRemoved(sender);
+            }
+        }
+    }
+}

package/src/version/ContractVersionBase.sol

@@ -9,6 +9,6 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 contract ContractVersionBase is IVersionedContract {
     /// @notice The version of the contract
     function contractVersion() external pure override returns (string memory) {
-        return "2.3.0";
+        return "2.4.0";
     }
 }