test: add fuzz tests and increase coverage

.gitignore

@@ -2,15 +2,8 @@
 cache/
 out/
 
-# Ignores development broadcast logs
-!/broadcast
-/broadcast/*/31337/
-/broadcast/**/dry-run/
-*broadcast/
-
-# Crytic
-crytic-export/
-medusa.json
+# Ignores all broadcast logs
+/broadcast
 
 # Docs
 docs/

foundry.toml

@@ -37,6 +37,8 @@ arbitrum-one = "${ARBITRUM_MAINNET_URL}"
 arbitrum-sepolia = "${ARBITRUM_SEPOLIA_URL}"
 avalanche = "${AVALANCHE_MAINNET_URL}"
 avalanche-fuji = "${AVALANCHE_FUJI_URL}"
+mantle = "${MANTLE_MAINNET_URL}"
+mantle-sepolia = "${MANTLE_SEPOLIA_URL}"
 
 [etherscan]
 mainnet = { key = "${ETHERSCAN_API_KEY}" }

script/DeployHostItTickets.s.sol

@@ -1,15 +1,10 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 pragma solidity 0.8.30;
 
-import {DiamondCutFacet} from "@diamond/facets/DiamondCutFacet.sol";
-import {DiamondLoupeFacet} from "@diamond/facets/DiamondLoupeFacet.sol";
-import {OwnableRolesFacet} from "@diamond/facets/OwnableRolesFacet.sol";
-import {DiamondInit} from "@diamond/initializers/DiamondInit.sol";
 import {IDiamondCut} from "@diamond/interfaces/IDiamondCut.sol";
 import {UpgradeableBeacon} from "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
 import {DeployHostItTicketsHelper} from "@ticket-script/helpers/DeployHostItTicketsHelper.sol";
 import {LibAddressesAndFees} from "@ticket-script/helpers/LibAddressesAndFees.sol";
-import {HostItTickets} from "@ticket/HostItTickets.sol";
 import {CheckInFacet} from "@ticket/facets/CheckInFacet.sol";
 import {FactoryFacet} from "@ticket/facets/FactoryFacet.sol";
 import {MarketplaceFacet} from "@ticket/facets/MarketplaceFacet.sol";

script/helpers/LibAddressesAndFees.sol

@@ -39,6 +39,9 @@ library LibAddressesAndFees {
         } else if (_chainId == 4202) {
             addresses_ = _getLiskSepoliaAddresses();
             feeTypes_ = _getLiskSepoliaFeeTypes();
+        } else if (_chainId == 5003) {
+            addresses_ = _getMantleSepoliaAddresses();
+            feeTypes_ = _getMantleSepoliaFeeTypes();
         } else if (_chainId == 31337) {
             addresses_ = _getMockAddresses();
             feeTypes_ = _getMockFeeTypes();
@@ -221,6 +224,22 @@ library LibAddressesAndFees {
         addresses_[3] = LISK_SEPOLIA_LSK;
     }
 
+    function _getMantleSepoliaFeeTypes() internal pure returns (uint8[] memory feeType_) {
+        feeType_ = new uint8[](4);
+        feeType_[0] = uint8(FeeType.USDC);
+        feeType_[1] = uint8(FeeType.USDT);
+        feeType_[2] = uint8(FeeType.LINK);
+        feeType_[3] = uint8(FeeType.WETH);
+    }
+
+    function _getMantleSepoliaAddresses() internal pure returns (address[] memory addresses_) {
+        addresses_ = new address[](4);
+        addresses_[0] = MANTLE_SEPOLIA_USDC;
+        addresses_[1] = MANTLE_SEPOLIA_USDT;
+        addresses_[2] = MANTLE_SEPOLIA_LINK;
+        addresses_[3] = MANTLE_SEPOLIA_WMNT;
+    }
+
     function _getMockFeeTypes() internal pure returns (uint8[] memory feeType_) {
         feeType_ = new uint8[](8);
         feeType_[0] = uint8(FeeType.WETH);
@@ -339,6 +358,26 @@ address constant ARBITRUM_SEPOLIA_USDC = 0x5Df6eD08EEC2fD5e41914d291c0cf48Cd3564
 address constant ARBITRUM_SEPOLIA_LINK = 0xb1D4538B4571d411F07960EF2838Ce337FE1E80E;
 address constant ARBITRUM_SEPOLIA_WETH = 0xE591bf0A0CF924A0674d7792db046B23CEbF5f34;
 
+//*//////////////////////////////////////////////////////////////////////////
+//                              MANTLE ADDRESSES
+//////////////////////////////////////////////////////////////////////////*//
+
+address constant MANTLE_ETH = 0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111;
+address constant MANTLE_USDT = 0x201EBa5CC46D216Ce6DC03F6a759e8E766e956aE;
+address constant MANTLE_USDC = 0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9;
+address constant MANTLE_LINK = 0xfe36cF0B43aAe49fBc5cFC5c0AF22a623114E043;
+address constant MANTLE_WMNT = 0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8;
+
+//*//////////////////////////////////////////////////////////////////////////
+//                          MANTLE SEPOLIA ADDRESSES
+//////////////////////////////////////////////////////////////////////////*//
+
+address constant MANTLE_SEPOLIA_ETH = 0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111;
+address constant MANTLE_SEPOLIA_USDT = 0x201EBa5CC46D216Ce6DC03F6a759e8E766e956aE;
+address constant MANTLE_SEPOLIA_USDC = 0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9;
+address constant MANTLE_SEPOLIA_LINK = 0x22bdEdEa0beBdD7CfFC95bA53826E55afFE9DE04;
+address constant MANTLE_SEPOLIA_WMNT = 0x19f5557E23e9914A18239990f6C70D68FDF0deD5;
+
 //*//////////////////////////////////////////////////////////////////////////
 //                            TOKENBOUND ADDRESSES
 //////////////////////////////////////////////////////////////////////////*//

src/libs/LibMarketplace.sol

@@ -47,26 +47,47 @@ library LibMarketplace {
 
         ExtraTicketData memory ticketData = _ticketId._getExtraTicketData();
 
-        uint48 time = block.timestamp.toUint48();
-        if (time < ticketData.purchaseStartTime) revert PurchaseTimeNotReached();
-        if (time > ticketData.endTime) revert PurchaseTimeNotReached();
-        if (ticketData.soldTickets == ticketData.maxTickets) revert TicketSoldOut();
+        {
+            uint48 time = block.timestamp.toUint48();
+            if (time < ticketData.purchaseStartTime) {
+                revert PurchaseTimeNotReached();
+            }
+            if (time > ticketData.endTime) revert PurchaseTimeNotReached();
+            if (ticketData.soldTickets == ticketData.maxTickets) {
+                revert TicketSoldOut();
+            }
+        }
 
         ITicket ticket = ITicket(ticketData.ticketAddress);
-        if (ticket.balanceOf(_buyer) > ticketData.maxTicketsPerUser) revert MaxTicketsHeld();
+        if (ticket.balanceOf(_buyer) > ticketData.maxTicketsPerUser) {
+            revert MaxTicketsHeld();
+        }
 
         MarketplaceStorage storage ms = _marketplaceStorage();
         (uint256 fee, uint256 hostItFee, uint256 totalFee) = _getFees(ms, _ticketId, _feeType);
         if (!ticketData.isFree) {
             if (!_isFeeEnabled(ms, _ticketId, _feeType)) revert FeeNotEnabled();
 
-            if (_feeType == FeeType.ETH) {
-                if (msg.value < totalFee) revert InsufficientBalance(address(0), _feeType, totalFee);
+            if (ticketData.isRefundable) {
+                if (_feeType == FeeType.ETH) {
+                    if (msg.value < totalFee) {
+                        revert TicketPurchaseFailed(_feeType, totalFee);
+                    }
+                } else {
+                    _payWithToken(ms, _feeType, totalFee, address(this));
+                }
+                ms.ticketBalance[_ticketId][_feeType] += fee;
             } else {
-                _payWithToken(ms, _feeType, totalFee);
+                if (_feeType == FeeType.ETH) {
+                    if (msg.value < totalFee) {
+                        revert TicketPurchaseFailed(_feeType, totalFee);
+                    }
+                    ticketData.ticketAdmin.forceSafeTransferETH(fee);
+                } else {
+                    _payWithToken(ms, _feeType, fee, ticketData.ticketAdmin);
+                    _payWithToken(ms, _feeType, hostItFee, address(this));
+                }
             }
-
-            ms.ticketBalance[_ticketId][_feeType] += fee;
             ms.hostItBalance[_feeType] += hostItFee;
         }
 
@@ -86,12 +107,16 @@ library LibMarketplace {
         _ticketId._checkTicketExists();
 
         uint256 feeTypesLength = _feeTypes.length;
-        if (feeTypesLength != _fees.length && feeTypesLength > 0) revert InvalidFeeConfig();
+        if (feeTypesLength != _fees.length && feeTypesLength > 0) {
+            revert InvalidFeeConfig();
+        }
         LibFactory._factoryStorage().ticketIdToData[_ticketId].isFree = false;
 
         MarketplaceStorage storage ms = _marketplaceStorage();
         for (uint256 i; i < feeTypesLength; ++i) {
-            if (_isFeeEnabled(ms, _ticketId, _feeTypes[i])) revert FeeAlreadySet();
+            if (_isFeeEnabled(ms, _ticketId, _feeTypes[i])) {
+                revert FeeAlreadySet();
+            }
             if (_fees[i] == 0) revert ZeroFee();
 
             ms.feeEnabled[_ticketId][_feeTypes[i]] = true;
@@ -110,7 +135,9 @@ library LibMarketplace {
 
         uint48 time = block.timestamp.toUint48();
         if (time < ticketData.endTime) revert RefundPeriodNotReached();
-        if (time > ticketData.endTime + REFUND_PERIOD) revert RefundPeriodExpired();
+        if (time > ticketData.endTime + REFUND_PERIOD) {
+            revert RefundPeriodExpired();
+        }
 
         address caller = LibContext._msgSender();
         ITicket ticket = ITicket(ticketData.ticketAddress);
@@ -143,7 +170,9 @@ library LibMarketplace {
         ExtraTicketData memory ticketData = _ticketId._getExtraTicketData();
 
         if (ticketData.isRefundable) {
-            if (block.timestamp < ticketData.endTime + REFUND_PERIOD) revert WithdrawPeriodNotReached();
+            if (block.timestamp < ticketData.endTime + REFUND_PERIOD) {
+                revert WithdrawPeriodNotReached();
+            }
         }
 
         uint256 balance = _getTicketBalance(_ticketId, _feeType);
@@ -175,23 +204,25 @@ library LibMarketplace {
         delete _marketplaceStorage().hostItBalance[_feeType];
 
         if (_feeType == FeeType.ETH) {
-            _to.safeTransferETH(balance);
+            _to.forceSafeTransferETH(balance);
         } else {
             _getFeeTokenAddress(_feeType).safeTransfer(_to, balance);
         }
         emit HostItBalanceWithdrawn(_feeType, balance, _to);
     }
 
-    function _payWithToken(MarketplaceStorage storage _ms, FeeType _feeType, uint256 _totalFee) internal {
+    function _payWithToken(MarketplaceStorage storage _ms, FeeType _feeType, uint256 _totalFee, address _to) internal {
         address caller = LibContext._msgSender();
 
         address tokenAddress = _getFeeTokenAddress(_ms, _feeType);
         IERC20 token = IERC20(tokenAddress);
-        if (token.balanceOf(caller) < _totalFee) revert InsufficientBalance(tokenAddress, _feeType, _totalFee);
+        if (token.balanceOf(caller) < _totalFee) {
+            revert InsufficientBalance(tokenAddress, _feeType, _totalFee);
+        }
         if (token.allowance(caller, address(this)) < _totalFee) {
             revert InsufficientAllowance(tokenAddress, _feeType, _totalFee);
         }
-        if (!tokenAddress.trySafeTransferFrom(caller, address(this), _totalFee)) {
+        if (!tokenAddress.trySafeTransferFrom(caller, _to, _totalFee)) {
             revert TicketPurchaseFailed(_feeType, _totalFee);
         }
     }
@@ -215,7 +246,9 @@ library LibMarketplace {
 
     function _setFeeTokenAddresses(FeeType[] calldata _feeTypes, address[] calldata _tokenAddresses) internal {
         uint256 feeTypesLength = _feeTypes.length;
-        if (feeTypesLength != _tokenAddresses.length && feeTypesLength > 0) revert InvalidFeeConfig();
+        if (feeTypesLength != _tokenAddresses.length && feeTypesLength > 0) {
+            revert InvalidFeeConfig();
+        }
         for (uint256 i; i < feeTypesLength; ++i) {
             if (_tokenAddresses[i] == address(0)) revert TokenAddressZero();
             _marketplaceStorage().feeTokenAddress[_feeTypes[i]] = _tokenAddresses[i];