@zoralabs/coins 0.7.1 → 1.0.0

package/src/libs/UniV4SwapToCurrency.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
+import {ISwapPathRouter} from "../interfaces/ISwapPathRouter.sol";
+import {IHasPoolKey} from "../interfaces/ICoinV4.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IPoolManager, PoolKey} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {IHasSwapPath} from "../interfaces/ICoinV4.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+import {IDeployedCoinVersionLookup} from "../interfaces/IDeployedCoinVersionLookup.sol";
+import {IZoraV4CoinHook} from "../interfaces/IZoraV4CoinHook.sol";
+import {CoinConfigurationVersions} from "./CoinConfigurationVersions.sol";
+
+library UniV4SwapToCurrency {
+    using BalanceDeltaLibrary for BalanceDelta;
+
+    function swapToPath(
+        IPoolManager poolManager,
+        uint128 amount0,
+        uint128 amount1,
+        Currency currencyIn,
+        PathKey[] memory path
+    ) internal returns (Currency lastCurrency, uint128 lastCurrencyBalance) {
+        require(path.length > 0, IZoraV4CoinHook.PathMustHaveAtLeastOneStep());
+
+        // do first swap - the first swap updates output the balance with the initial balance that existed before the swap
+        (lastCurrency, lastCurrencyBalance) = _doFirstSwapFromCoinToCurrency(poolManager, path[0], currencyIn, amount0, amount1);
+
+        // for each path, swap the currency to the next currency
+        for (uint256 i = 1; i < path.length; i++) {
+            (PoolKey memory poolKey, bool zeroForOne) = _getPoolAndSwapDirection(path[i], lastCurrency);
+            lastCurrencyBalance = uint128(_swap(poolManager, poolKey, zeroForOne, -int128(lastCurrencyBalance), ""));
+            lastCurrency = zeroForOne ? poolKey.currency1 : poolKey.currency0;
+        }
+    }
+
+    function _doFirstSwapFromCoinToCurrency(
+        IPoolManager poolManager,
+        PathKey memory pathKey,
+        Currency coin,
+        uint128 amount0,
+        uint128 amount1
+    ) private returns (Currency outputCurrency, uint128 outputAmount) {
+        (PoolKey memory poolKey, bool zeroForOne) = _getPoolAndSwapDirection(pathKey, coin);
+
+        uint128 coinAmount = zeroForOne ? amount0 : amount1;
+
+        outputCurrency = zeroForOne ? poolKey.currency1 : poolKey.currency0;
+
+        uint128 initialAmountCurrency = zeroForOne ? amount1 : amount0;
+
+        // if not swapping any coin for currency, output amount is amount of currency
+        if (coinAmount == 0) {
+            outputAmount = initialAmountCurrency;
+        } else {
+            outputAmount = uint128(_swap(poolManager, poolKey, zeroForOne, -int128(coinAmount), bytes("")));
+        }
+    }
+
+    function _swap(
+        IPoolManager poolManager,
+        PoolKey memory poolKey,
+        bool zeroForOne,
+        int256 amountSpecified,
+        bytes memory hookData
+    ) private returns (int128 reciprocalAmount) {
+        // for protection of exactOut swaps, sqrtPriceLimit is not exposed as a feature in this contract
+        unchecked {
+            BalanceDelta delta = poolManager.swap(
+                poolKey,
+                SwapParams(zeroForOne, amountSpecified, zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
+                hookData
+            );
+
+            reciprocalAmount = (zeroForOne == amountSpecified < 0) ? delta.amount1() : delta.amount0();
+        }
+    }
+
+    /// @notice Get the pool and swap direction for a given PathKey
+    /// @param params the given PathKey
+    /// @param currencyIn the input currency
+    /// @return poolKey the pool key of the swap
+    /// @return zeroForOne the direction of the swap, true if currency0 is being swapped for currency1
+    function _getPoolAndSwapDirection(PathKey memory params, Currency currencyIn) internal pure returns (PoolKey memory poolKey, bool zeroForOne) {
+        Currency currencyOut = params.intermediateCurrency;
+        (Currency currency0, Currency currency1) = currencyIn < currencyOut ? (currencyIn, currencyOut) : (currencyOut, currencyIn);
+
+        zeroForOne = currencyIn == currency0;
+        poolKey = PoolKey(currency0, currency1, params.fee, params.tickSpacing, params.hooks);
+    }
+
+    function getSubSwapPath(address currency, IDeployedCoinVersionLookup coinVersionLookup) internal view returns (PathKey[] memory) {
+        if (!_hasSwapPath(currency, coinVersionLookup)) {
+            return new PathKey[](0);
+        }
+        return IHasSwapPath(currency).getPayoutSwapPath(coinVersionLookup).path;
+    }
+
+    function _hasSwapPath(address currency, IDeployedCoinVersionLookup coinVersionLookup) private view returns (bool) {
+        if (CoinConfigurationVersions.isV4(coinVersionLookup.getVersionForDeployedCoin(currency))) {
+            return IERC165(currency).supportsInterface(type(IHasSwapPath).interfaceId);
+        }
+        return false;
+    }
+}

package/src/libs/V4Liquidity.sol

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {SqrtPriceMath} from "@uniswap/v4-core/src/libraries/SqrtPriceMath.sol";
+import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
+import {IUnlockCallback} from "@uniswap/v4-core/src/interfaces/callback/IUnlockCallback.sol";
+import {IPoolManager, PoolKey, IHooks, ModifyLiquidityParams, BalanceDelta} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
+import {LpPosition} from "../types/LpPosition.sol";
+import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {IHasRewardsRecipients} from "../interfaces/ICoin.sol";
+import {IHasSwapPath} from "../interfaces/ICoinV4.sol";
+import {UniV4SwapToCurrency} from "./UniV4SwapToCurrency.sol";
+import {PathKey} from "@uniswap/v4-periphery/src/libraries/PathKey.sol";
+
+// command = 1; mint
+struct CallbackData {
+    PoolKey poolKey;
+    LpPosition[] positions;
+}
+
+struct UnlockData {
+    uint256 amount0;
+    uint256 amount1;
+    int128 fees0;
+    int128 fees1;
+}
+
+library V4Liquidity {
+    using BalanceDeltaLibrary for BalanceDelta;
+    using CurrencyLibrary for Currency;
+
+    function lockAndMint(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] memory positions) internal {
+        bytes memory data = abi.encode(CallbackData({poolKey: poolKey, positions: positions}));
+
+        IPoolManager(poolManager).unlock(data);
+    }
+
+    function handleMintPositionsCallback(IPoolManager poolManager, bytes memory data) internal returns (UnlockData memory) {
+        CallbackData memory callbackData = abi.decode(data, (CallbackData));
+
+        uint256 amount0;
+        uint256 amount1;
+        int128 fees0;
+        int128 fees1;
+
+        (fees0, fees1) = _mintPositions(poolManager, callbackData.poolKey, callbackData.positions);
+
+        _settleUp(poolManager, callbackData.poolKey);
+
+        return UnlockData({amount0: amount0, amount1: amount1, fees0: fees0, fees1: fees1});
+    }
+
+    function collectFees(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] storage positions) internal returns (int128 balance0, int128 balance1) {
+        ModifyLiquidityParams memory params;
+        uint256 numPositions = positions.length;
+
+        for (uint256 i; i < numPositions; i++) {
+            params = ModifyLiquidityParams({
+                tickLower: positions[i].tickLower,
+                tickUpper: positions[i].tickUpper,
+                liquidityDelta: 0, // only collect
+                salt: 0
+            });
+
+            (, BalanceDelta feesDelta) = poolManager.modifyLiquidity(poolKey, params, "");
+
+            // check if there is enough erc20 balance for each token to take the fees
+            balance0 += feesDelta.amount0();
+            balance1 += feesDelta.amount1();
+        }
+    }
+
+    function _mintPositions(IPoolManager poolManager, PoolKey memory poolKey, LpPosition[] memory positions) private returns (int128 amount0, int128 amount1) {
+        ModifyLiquidityParams memory params;
+        uint256 numPositions = positions.length;
+
+        for (uint256 i; i < numPositions; i++) {
+            params = ModifyLiquidityParams({
+                tickLower: positions[i].tickLower,
+                tickUpper: positions[i].tickUpper,
+                liquidityDelta: SafeCast.toInt256(positions[i].liquidity),
+                salt: 0
+            });
+
+            (BalanceDelta delta, ) = poolManager.modifyLiquidity(poolKey, params, "");
+
+            amount0 += delta.amount0();
+            amount1 += delta.amount1();
+        }
+    }
+
+    function _settleUp(IPoolManager poolManager, PoolKey memory poolKey) private returns (int256 currency0Delta, int256 currency1Delta) {
+        // calculate the current deltas
+        currency0Delta = TransientStateLibrary.currencyDelta(poolManager, address(this), poolKey.currency0);
+        currency1Delta = TransientStateLibrary.currencyDelta(poolManager, address(this), poolKey.currency1);
+
+        _settleDeltas(poolManager, poolKey, currency0Delta, currency1Delta);
+    }
+
+    function _settleDeltas(IPoolManager poolManager, PoolKey memory poolKey, int256 currency0Delta, int256 currency1Delta) private {
+        if (currency0Delta > 0) {
+            poolManager.take(poolKey.currency0, address(this), uint256(currency0Delta));
+        }
+
+        if (currency1Delta > 0) {
+            poolManager.take(poolKey.currency1, address(this), uint256(currency1Delta));
+        }
+
+        if (currency0Delta < 0) {
+            poolManager.sync(poolKey.currency0);
+            poolKey.currency0.transfer(address(poolManager), uint256(-currency0Delta));
+            poolManager.settle();
+        }
+
+        if (currency1Delta < 0) {
+            poolManager.sync(poolKey.currency1);
+            poolKey.currency1.transfer(address(poolManager), uint256(-currency1Delta));
+            poolManager.settle();
+        }
+    }
+}

package/src/types/PoolConfiguration.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @notice The configuration of the pool
+/// @dev This is used to configure the pool's liquidity positions
+struct PoolConfiguration {
+    uint8 version;
+    uint16 numPositions;
+    uint24 fee;
+    int24 tickSpacing;
+    uint16[] numDiscoveryPositions;
+    int24[] tickLower;
+    int24[] tickUpper;
+    uint256[] maxDiscoverySupplyShare;
+}

package/src/utils/DeployedCoinVersionLookup.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IDeployedCoinVersionLookup} from "../interfaces/IDeployedCoinVersionLookup.sol";
+
+/**
+ * @title DeployedCoinVersionLookup
+ * @notice Contract for storing and retrieving version information for deployed coins
+ * @dev Uses the ERC-7201 static storage slot pattern for upgradeable storage
+ */
+contract DeployedCoinVersionLookup is IDeployedCoinVersionLookup {
+    struct DeployedCoinVersion {
+        uint8 version;
+    }
+
+    /// @custom:storage-location erc7201:zora.coins.deployedcoinversionlookup.storage
+    struct DeployedCoinVersionStorage {
+        mapping(address => DeployedCoinVersion) deployedCoinWithVersion;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("zora.coins.deployedcoinversionlookup.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant DEPLOYED_COIN_VERSION_STORAGE_LOCATION = 0x9a79df0b86f39d0543c14aee714123562f798115071e932933bcc3e29cc86f00;
+
+    /**
+     * @dev Returns the storage slot struct for deployed coin versions
+     * @return $ Storage struct containing the deployedCoinWithVersion mapping
+     */
+    function _getDeployedCoinVersionStorage() private pure returns (DeployedCoinVersionStorage storage $) {
+        assembly {
+            $.slot := DEPLOYED_COIN_VERSION_STORAGE_LOCATION
+        }
+    }
+
+    /**
+     * @notice Gets the version for a deployed coin
+     * @param coin The address of the coin
+     * @return version The version of the coin (0 if not found)
+     */
+    function getVersionForDeployedCoin(address coin) public view returns (uint8) {
+        return _getDeployedCoinVersionStorage().deployedCoinWithVersion[coin].version;
+    }
+
+    /**
+     * @notice Sets the version for a deployed coin
+     * @dev Only callable internally
+     * @param coin The address of the coin
+     * @param version The version to set
+     */
+    function _setVersionForDeployedCoin(address coin, uint8 version) internal {
+        _getDeployedCoinVersionStorage().deployedCoinWithVersion[coin] = DeployedCoinVersion({version: version});
+    }
+}

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 "0.7.1";
+        return "1.0.0";
     }
 }