@towns-protocol/contracts 0.0.302

package/src/utils/airdrop/merkle/MerkleAirdrop.sol

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IMerkleAirdrop} from "./IMerkleAirdrop.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+
+import {MerkleAirdropStorage} from "./MerkleAirdropStorage.sol";
+import {ECDSA} from "solady/utils/ECDSA.sol";
+import {MerkleProofLib} from "solady/utils/MerkleProofLib.sol";
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+
+// contracts
+
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {EIP712Base} from "@towns-protocol/diamond/src/utils/cryptography/EIP712Base.sol";
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+
+contract MerkleAirdrop is IMerkleAirdrop, EIP712Base, Facet {
+    // keccak256("AirdropClaim(address account,uint256 amount,address receiver)");
+    bytes32 private constant MESSAGE_TYPEHASH =
+        0x0770323f1f7513b8a3d8df16b4b8fd506e7a76eaf71c03c687683b8d52979b5c;
+
+    function __MerkleAirdrop_init(bytes32 merkleRoot, IERC20 token) external initializer {
+        _addInterface(type(IMerkleAirdrop).interfaceId);
+        __MerkleAirdrop_init_unchained(merkleRoot, token);
+    }
+
+    /// @inheritdoc IMerkleAirdrop
+    function getMerkleRoot() public view returns (bytes32) {
+        return MerkleAirdropStorage.layout().merkleRoot;
+    }
+
+    /// @inheritdoc IMerkleAirdrop
+    function getToken() public view returns (IERC20) {
+        return MerkleAirdropStorage.layout().token;
+    }
+
+    /// @inheritdoc IMerkleAirdrop
+    function getMessageHash(
+        address account,
+        uint256 amount,
+        address receiver
+    ) public view returns (bytes32) {
+        return
+            _hashTypedDataV4(
+                keccak256(abi.encode(MESSAGE_TYPEHASH, AirdropClaim(account, amount, receiver)))
+            );
+    }
+
+    /// @inheritdoc IMerkleAirdrop
+    function claim(
+        address account,
+        uint256 amount,
+        bytes32[] calldata merkleProof,
+        bytes calldata signature,
+        address receiver
+    ) external {
+        MerkleAirdropStorage.Layout storage ds = MerkleAirdropStorage.layout();
+
+        if (ds.claimed[account]) {
+            CustomRevert.revertWith(MerkleAirdrop__AlreadyClaimed.selector);
+        }
+
+        _validateSignature(account, getMessageHash(account, amount, receiver), signature);
+
+        // verify merkle proof
+        bytes32 leaf = _createLeaf(account, amount);
+        if (!MerkleProofLib.verifyCalldata(merkleProof, ds.merkleRoot, leaf)) {
+            CustomRevert.revertWith(MerkleAirdrop__InvalidProof.selector);
+        }
+
+        ds.claimed[account] = true;
+
+        address recipient = receiver == address(0) ? account : receiver;
+        emit Claimed(account, amount, recipient);
+
+        SafeTransferLib.safeTransfer(address(ds.token), recipient, amount);
+    }
+
+    // =============================================================
+    //                           Internal
+    // =============================================================
+    function __MerkleAirdrop_init_unchained(bytes32 merkleRoot, IERC20 token) internal {
+        MerkleAirdropStorage.Layout storage ds = MerkleAirdropStorage.layout();
+        ds.merkleRoot = merkleRoot;
+        ds.token = token;
+    }
+
+    function _validateSignature(
+        address signer,
+        bytes32 digest,
+        bytes calldata signature
+    ) internal view {
+        address actualSigner = ECDSA.recoverCalldata(digest, signature);
+        if (actualSigner != signer) {
+            CustomRevert.revertWith(MerkleAirdrop__InvalidSignature.selector);
+        }
+    }
+
+    function _createLeaf(address account, uint256 amount) internal pure returns (bytes32 leaf) {
+        assembly ("memory-safe") {
+            // Store the account address at memory location 0
+            mstore(0, account)
+            // Store the amount at memory location 0x20 (32 bytes after the account address)
+            mstore(0x20, amount)
+            // Compute the keccak256 hash of the account and amount, and store it at memory location
+            // 0
+            mstore(0, keccak256(0, 0x40))
+            // Compute the keccak256 hash of the previous hash (stored at memory location 0) and
+            // store it
+            // in the leaf variable
+            leaf := keccak256(0, 0x20)
+        }
+    }
+}

package/src/utils/airdrop/merkle/MerkleAirdropStorage.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+
+// contracts
+
+library MerkleAirdropStorage {
+    // keccak256(abi.encode(uint256(keccak256("merkle.airdrop.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 constant STORAGE_SLOT =
+        0x5499e8f18bf9226c15306964dca998d3d8d3ddae851b652336bc6dea221b5200;
+
+    struct Layout {
+        IERC20 token;
+        bytes32 merkleRoot;
+        mapping(address => bool) claimed;
+    }
+
+    function layout() internal pure returns (Layout storage ds) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            ds.slot := slot
+        }
+    }
+}

package/src/utils/interfaces/AggregatorV3Interface.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface AggregatorV3Interface {
+    function decimals() external view returns (uint8);
+
+    function description() external view returns (string memory);
+
+    function version() external view returns (uint256);
+
+    // getRoundData and latestRoundData should both raise "No data present"
+    // if they do not have data to report, instead of returning unset values
+    // which could be misinterpreted as actual reported values.
+    function getRoundData(
+        uint80 _roundId
+    )
+        external
+        view
+        returns (
+            uint80 roundId,
+            int256 answer,
+            uint256 startedAt,
+            uint256 updatedAt,
+            uint80 answeredInRound
+        );
+
+    function latestRoundData()
+        external
+        view
+        returns (
+            uint80 roundId,
+            int256 answer,
+            uint256 startedAt,
+            uint256 updatedAt,
+            uint80 answeredInRound
+        );
+}

package/src/utils/interfaces/IMulticall.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.8;
+
+/// @title Interface for the Multicall utility contract
+interface IMulticall {
+    /// @notice batch function calls to the contract and return the results of each
+    /// @param data array of function call data payloads
+    /// @return results array of function call results
+    function multicall(bytes[] calldata data) external returns (bytes[] memory results);
+}

package/src/utils/interfaces/IWETH.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IWETH {
+    function deposit() external payable;
+
+    function withdraw(uint256 amount) external;
+
+    function transfer(address to, uint256 value) external returns (bool);
+}

package/src/utils/libraries/BasisPoints.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {CustomRevert} from "./CustomRevert.sol";
+
+/// @title Basis Points
+/// @notice Library for calculating with basis points
+library BasisPoints {
+    using CustomRevert for bytes4;
+
+    uint256 public constant MAX_BPS = 10_000;
+
+    error InvalidBasisPoints(uint256 basisPoints);
+
+    /// @notice Calculate the basis points of a given amount
+    /// @param amount The amount to be multiplied by the basis points
+    /// @param basisPoints The basis points
+    /// @return The amount multiplied by the basis points
+    function calculate(uint256 amount, uint256 basisPoints) internal pure returns (uint256) {
+        if (basisPoints > MAX_BPS) InvalidBasisPoints.selector.revertWith(basisPoints);
+
+        return (amount * basisPoints) / MAX_BPS;
+    }
+}

package/src/utils/libraries/Create2Utils.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {LibClone} from "solady/utils/LibClone.sol";
+
+library Create2Utils {
+    address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
+
+    error MissingCreate2Factory();
+    error Create2AddressDerivationFailed();
+    error Create2CallFailed();
+
+    function create2Deploy(bytes32 salt, bytes memory bytecode) internal returns (address) {
+        if (!isContractDeployed(CREATE2_FACTORY)) {
+            CustomRevert.revertWith(MissingCreate2Factory.selector);
+        }
+
+        address computed = computeCreate2Address(salt, bytecode);
+
+        if (isContractDeployed(computed)) {
+            return computed;
+        } else {
+            address deployedAt = performCreate2Call(salt, bytecode);
+            if (deployedAt != computed) {
+                CustomRevert.revertWith(Create2AddressDerivationFailed.selector);
+            }
+            return deployedAt;
+        }
+    }
+
+    function isContractDeployed(address addr) internal view returns (bool isContract) {
+        assembly ("memory-safe") {
+            isContract := gt(extcodesize(addr), 0)
+        }
+    }
+
+    function computeCreate2Address(
+        bytes32 salt,
+        bytes memory bytecode
+    ) internal pure returns (address) {
+        return LibClone.predictDeterministicAddress(keccak256(bytecode), salt, CREATE2_FACTORY);
+    }
+
+    function performCreate2Call(
+        bytes32 salt,
+        bytes memory bytecode
+    ) internal returns (address deployedAt) {
+        bytes memory data = abi.encodePacked(salt, bytecode);
+
+        assembly ("memory-safe") {
+            // If call failed, revert with empty data
+            if iszero(
+                call(
+                    gas(), // Forward all available gas
+                    CREATE2_FACTORY, // Address of the CREATE2 factory
+                    0, // No ETH value
+                    add(data, 0x20), // Pointer to data (skip length prefix)
+                    mload(data), // Data size
+                    0, // Output location
+                    0x20 // Output size (32 bytes)
+                )
+            ) {
+                // Inline revert with empty data
+                revert(0, 0)
+            }
+            deployedAt := shr(96, mload(0))
+        }
+
+        if (deployedAt == address(0)) {
+            CustomRevert.revertWith(Create2CallFailed.selector);
+        }
+    }
+}

package/src/utils/libraries/CurrencyTransfer.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IWETH} from "../interfaces/IWETH.sol";
+
+// libraries
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+import {CustomRevert} from "./CustomRevert.sol";
+
+// contracts
+
+library CurrencyTransfer {
+    using SafeTransferLib for address;
+    using CustomRevert for bytes4;
+
+    /// @dev The address interpreted as native token of the chain.
+    address internal constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+
+    /// @dev The ETH transfer has failed.
+    error ETHTransferFailed();
+
+    /// @dev The ERC20 `transferFrom` has failed.
+    error TransferFromFailed();
+
+    /// @dev The ERC20 `transfer` has failed.
+    error TransferFailed();
+
+    /// @dev The `msg.value` does not match the amount.
+    error MsgValueMismatch();
+
+    /// @dev Transfers a given amount of currency.
+    /// @param currency The currency to transfer.
+    /// @param from The address to transfer from.
+    /// @param to The address to transfer to.
+    /// @param amount The amount to transfer.
+    function transferCurrency(address currency, address from, address to, uint256 amount) internal {
+        if (amount == 0) return;
+
+        if (currency != NATIVE_TOKEN) safeTransferERC20(currency, from, to, amount);
+        else safeTransferNativeToken(to, amount);
+    }
+
+    /// @dev Transfers a given amount of currency. (With native token wrapping)
+    /// @param currency The currency to transfer.
+    /// @param from The address to transfer from.
+    /// @param to The address to transfer to.
+    /// @param amount The amount to transfer.
+    /// @param _nativeTokenWrapper The address of the native token wrapper.
+    function transferCurrencyWithWrapper(
+        address currency,
+        address from,
+        address to,
+        uint256 amount,
+        address _nativeTokenWrapper
+    ) internal {
+        if (amount == 0) return;
+
+        if (currency == NATIVE_TOKEN) {
+            if (from == address(this)) {
+                IWETH(_nativeTokenWrapper).withdraw(amount);
+                safeTransferNativeTokenWithWrapper(to, amount, _nativeTokenWrapper);
+            } else {
+                if (amount != msg.value) MsgValueMismatch.selector.revertWith();
+
+                if (to == address(this)) IWETH(_nativeTokenWrapper).deposit{value: msg.value}();
+                else safeTransferNativeTokenWithWrapper(to, msg.value, _nativeTokenWrapper);
+            }
+        } else {
+            safeTransferERC20(currency, from, to, amount);
+        }
+    }
+
+    /// @dev Transfer `amount` of ERC20 token from `from` to `to`.
+    function safeTransferERC20(address token, address from, address to, uint256 amount) internal {
+        if (from == to) return;
+
+        if (from != address(this)) token.safeTransferFrom(from, to, amount);
+        else token.safeTransfer(to, amount);
+    }
+
+    /// @dev Transfers `amount` of native token to `to`.
+    function safeTransferNativeToken(address to, uint256 value) internal {
+        to.safeTransferETH(value);
+    }
+
+    /// @dev Transfers `amount` of native token to `to`. (With native token wrapping)
+    function safeTransferNativeTokenWithWrapper(
+        address to,
+        uint256 value,
+        address _nativeTokenWrapper
+    ) internal {
+        bool success = to.trySafeTransferETH(value, gasleft());
+        if (!success) {
+            IWETH(_nativeTokenWrapper).deposit{value: value}();
+            _nativeTokenWrapper.safeTransfer(to, value);
+        }
+    }
+}

package/src/utils/libraries/CustomRevert.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @title Library for reverting with custom errors efficiently
+/// @notice Contains functions for reverting with custom errors with different argument types
+/// efficiently
+/// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert
+/// CustomError()` with
+/// `CustomError.selector.revertWith()`
+/// @dev The functions may tamper with the free memory pointer but it is fine since the call context
+/// is exited immediately
+library CustomRevert {
+    /// @dev Reverts with the selector of a custom error in the scratch space
+    function revertWith(bytes4 selector) internal pure {
+        assembly ("memory-safe") {
+            mstore(0, selector)
+            revert(0, 0x04)
+        }
+    }
+
+    /// @dev Reverts with a custom error with a uint256 argument in the scratch space
+    function revertWith(bytes4 selector, uint256 value) internal pure {
+        assembly ("memory-safe") {
+            mstore(0, selector)
+            mstore(0x04, value)
+            revert(0, 0x24)
+        }
+    }
+
+    /// @dev Reverts with a custom error with an address argument in the scratch space
+    function revertWith(bytes4 selector, address addr) internal pure {
+        assembly ("memory-safe") {
+            mstore(0, selector)
+            mstore(0x04, and(addr, 0xffffffffffffffffffffffffffffffffffffffff))
+            revert(0, 0x24)
+        }
+    }
+
+    /// @dev Reverts with the legacy error message without additional allocation
+    function revertWith(string memory message) internal pure {
+        assembly ("memory-safe") {
+            mstore(sub(message, 0x40), 0x08c379a0) // Error(string)
+            mstore(sub(message, 0x20), 0x20) // abi encoding offset
+            // round up to multiple of 32
+            let len := and(add(mload(message), 0x1f), not(0x1f))
+            revert(sub(message, 0x24), add(len, 0x44))
+        }
+    }
+}

package/src/utils/libraries/Factory.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {LibClone} from "solady/utils/LibClone.sol";
+
+/// @title Factory for arbitrary code deployment using the "CREATE" and "CREATE2" opcodes
+library Factory {
+    /// @notice Emitted when deployment fails
+    /// @param revertData Nested revert data
+    error Factory__FailedDeployment(bytes revertData);
+
+    /// @notice deploy contract code using "CREATE" opcode
+    /// @param initCode contract initialization code
+    /// @return deployment address of deployed contract
+    function deploy(bytes memory initCode) internal returns (address deployment) {
+        assembly ("memory-safe") {
+            deployment := create(0, add(initCode, 0x20), mload(initCode))
+            if iszero(deployment) {
+                // revert Factory__FailedDeployment(revertData)
+                mstore(0, 0x2b1c2246)
+                mstore(0x20, 0x20)
+                mstore(0x40, returndatasize())
+                returndatacopy(0x60, 0, returndatasize())
+                // round up to nearest 32 bytes
+                let rounded_len := and(not(0x1f), add(0x1f, returndatasize()))
+                revert(0x1c, add(0x44, rounded_len))
+            }
+        }
+    }
+
+    /// @notice deploy contract code using "CREATE2" opcode
+    /// @dev reverts if deployment is not successful (likely because salt has already been used)
+    /// @param initCode contract initialization code
+    /// @param salt input for deterministic address calculation
+    /// @return deployment address of deployed contract
+    function deploy(bytes memory initCode, bytes32 salt) internal returns (address deployment) {
+        assembly ("memory-safe") {
+            deployment := create2(0, add(initCode, 0x20), mload(initCode), salt)
+            if iszero(deployment) {
+                // revert Factory__FailedDeployment(revertData)
+                mstore(0, 0x2b1c2246)
+                mstore(0x20, 0x20)
+                mstore(0x40, returndatasize())
+                returndatacopy(0x60, 0, returndatasize())
+                // round up to nearest 32 bytes
+                let rounded_len := and(not(0x1f), add(0x1f, returndatasize()))
+                revert(0x1c, add(0x44, rounded_len))
+            }
+        }
+    }
+
+    /// @notice calculate the _deployMetamorphicContract deployment address for a given salt
+    /// @param initCodeHash hash of contract initialization code
+    /// @param salt input for deterministic address calculation
+    /// @return deployment deployment address
+    function calculateDeploymentAddress(
+        bytes32 initCodeHash,
+        bytes32 salt
+    ) internal view returns (address deployment) {
+        deployment = LibClone.predictDeterministicAddress(initCodeHash, salt, address(this));
+        assembly {
+            // clean the upper 96 bits
+            deployment := and(deployment, 0xffffffffffffffffffffffffffffffffffffffff)
+        }
+    }
+}