Custom entitlement factory to enable POAP gating

contracts/scripts/deployments/utils/DeployPoapEntitlementFactory.s.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.23;
+
+import {Deployer} from "contracts/scripts/common/Deployer.s.sol";
+import {PoapEntitlementFactory} from "contracts/src/spaces/entitlements/poap/PoapEntitlementFactory.sol";
+
+contract DeployPoapEntitlementFactory is Deployer {
+  function versionName() public pure override returns (string memory) {
+    return "DeployPoapEntitlementFactory";
+  }
+
+  function __deploy(address deployer) public override returns (address) {
+    vm.broadcast(deployer);
+
+    PoapEntitlementFactory factory = new PoapEntitlementFactory();
+
+    return address(factory);
+  }
+}

contracts/src/spaces/entitlements/poap/PoapEntitlement.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {ICustomEntitlement} from "contracts/src/spaces/entitlements/ICustomEntitlement.sol";
+
+interface IPOAP {
+  function balanceOf(address owner) external view returns (uint256);
+  function tokenDetailsOfOwnerByIndex(
+    address owner,
+    uint256 index
+  ) external view returns (uint256 eventId, uint256 tokenId);
+}
+
+IPOAP constant poapContract = IPOAP(0x22C1f6050E56d2876009903609a2cC3fEf83B415);
+
+contract PoapEntitlement is ICustomEntitlement {
+  uint256 public immutable eventId;
+
+  constructor(uint256 _eventId) {
+    require(_eventId > 0, "Invalid event ID");
+    eventId = _eventId;
+  }
+
+  function isEntitled(
+    address[] calldata wallets
+  ) external view override returns (bool) {
+    for (uint256 i = 0; i < wallets.length; i++) {
+      if (_hasEventPoap(wallets[i])) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function _hasEventPoap(address user) internal view returns (bool) {
+    uint256 balance = poapContract.balanceOf(user);
+    for (uint256 j = 0; j < balance; j++) {
+      (uint256 ownedEventId, ) = poapContract.tokenDetailsOfOwnerByIndex(
+        user,
+        j
+      );
+      if (eventId == ownedEventId) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

contracts/src/spaces/entitlements/poap/PoapEntitlementFactory.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Factory} from "contracts/src/utils/Factory.sol";
+import {PoapEntitlement} from "./PoapEntitlement.sol";
+
+contract PoapEntitlementFactory is Factory {
+  function deployEntitlement(uint256 eventId) public {
+    bytes32 salt = getSalt(eventId);
+    address predictedAddress = predictEntitlementAddress(eventId);
+
+    // Check if the contract is already deployed
+    uint32 size;
+    assembly {
+      size := extcodesize(predictedAddress)
+    }
+    require(size == 0, "Entitlement already deployed for this event");
+
+    bytes memory initCode = abi.encodePacked(
+      type(PoapEntitlement).creationCode,
+      abi.encode(eventId)
+    );
+
+    address deployment = _deploy(initCode, salt);
+    if (deployment != predictedAddress) {
+      revert("Deployment failed");
+    }
+  }
+
+  function getEntitlementAddress(
+    uint256 eventId
+  ) public view returns (address) {
+    return predictEntitlementAddress(eventId);
+  }
+
+  function getSalt(uint256 eventId) public pure returns (bytes32) {
+    return keccak256(abi.encodePacked("POAP", eventId));
+  }
+
+  function predictEntitlementAddress(
+    uint256 eventId
+  ) public view returns (address) {
+    bytes32 initCodeHash = keccak256(
+      abi.encodePacked(type(PoapEntitlement).creationCode, abi.encode(eventId))
+    );
+    return _calculateDeploymentAddress(initCodeHash, getSalt(eventId));
+  }
+}

foundry.toml

@@ -39,6 +39,7 @@ sepolia = "${SEPOLIA_RPC_URL}"
 base_sepolia = "${BASE_SEPOLIA_RPC_URL}"
 base = "${BASE_RPC_URL}"
 mainnet = "${MAINNET_RPC_URL}"
+gnosis = "${GNOSIS_RPC_URL}"
 
 [fmt]
 line_length = 80