Add talent protocol discount validator (#97)

* init

* First pass impl

* Natspec

* Add tests

* Add zero-address checks

* Address PR comments

* Fix typo

* Add clarity to possible revert case.

src/L2/discounts/TalentProtocolDiscountValidator.sol

@@ -0,0 +1,71 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {Ownable} from "solady/auth/Ownable.sol";
+
+import {IDiscountValidator} from "src/L2/interface/IDiscountValidator.sol";
+
+/// @title Discount Validator for: Talent Protocol Builder Score
+///
+/// @notice Enables discounts for users who have minted their Talent Protocol Builder Score .
+///         Discounts are granted based on the claimer having some score higher than this contract's `threshold`.
+///
+/// @author Coinbase (https://github.com/base-org/usernames)
+contract TalentProtocolDiscountValidator is IDiscountValidator, Ownable {
+    /// @notice Thrown when setting a critical address to the zero-address.
+    error NoZeroAddress();
+
+    /// @notice Emitted when the threshold is updated by the `owner`.
+    event ThresholdUpdated(uint256 newThreshold);
+
+    /// @notice Interface with the Talent Protocol `PassportBuilderScore` contract.
+    TalentProtocol immutable talentProtocol;
+
+    /// @notice The score threshold for qualifying for a discount.
+    uint256 public threshold;
+
+    /// @notice constructor
+    ///
+    /// @param owner_ The `Ownable` contract `owner`.
+    /// @param talentProtocol_ The address of the Talent Protocol PassportBuilderScore contract.
+    /// @param threshold_ The score required to qualify for a discount.
+    constructor(address owner_, address talentProtocol_, uint256 threshold_) {
+        if (owner_ == address(0)) revert NoZeroAddress();
+        if (talentProtocol_ == address(0)) revert NoZeroAddress();
+        talentProtocol = TalentProtocol(talentProtocol_);
+        threshold = threshold_;
+        _initializeOwner(owner_);
+    }
+
+    /// @notice Allows the `owner` to set the qualifying threshold.
+    ///
+    /// @param threshold_ The new discount-qualifying threshold.
+    function setThreshold(uint256 threshold_) external onlyOwner {
+        threshold = threshold_;
+        emit ThresholdUpdated(threshold_);
+    }
+
+    /// @notice Required implementation for compatibility with IDiscountValidator.
+    ///
+    /// @dev No additional data is required for validating this discount.
+    ///     NOTE: The call to `getScoreByAddress` can revert. This case should be handled gracefully by integrators.
+    ///
+    /// @param claimer the discount claimer's address.
+    ///
+    /// @return `true` if the validation data provided is determined to be valid for the specified claimer, else `false`.
+    function isValidDiscountRegistration(address claimer, bytes calldata) external view returns (bool) {
+        return (talentProtocol.getScoreByAddress(claimer) >= threshold);
+    }
+}
+
+/// @notice Lightweight interface for the PassportBuilderScore.sol contract.
+///         https://basescan.org/address/0xBBFeDA7c4d8d9Df752542b03CdD715F790B32D0B#readContract
+interface TalentProtocol {
+    /// @notice Gets the score of a given address.
+    ///
+    /// @param wallet The address to get the score for.
+    ///
+    /// @return The score of the given address.
+    function getScoreByAddress(address wallet) external view returns (uint256);
+}

test/discounts/TalenProtocolDiscountValidator/IsValidDiscountRegistration.t.sol

@@ -0,0 +1,24 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {TalentProtocolDiscountValidatorBase} from "./TalentProtocolDiscountValidatorBase.t.sol";
+
+contract IsValidDiscountRegistration is TalentProtocolDiscountValidatorBase {
+    function test_returnsTrue_whenTheScoreMeetsTheThreshold() public {
+        talent.setScore(threshold);
+        bool ret = validator.isValidDiscountRegistration(userA, "");
+        assertTrue(ret);
+    }
+
+    function test_returnsTrue_whenTheScoreExceedsTheThreshold() public {
+        talent.setScore(threshold + 1);
+        bool ret = validator.isValidDiscountRegistration(userA, "");
+        assertTrue(ret);
+    }
+
+    function test_returnsFalse_whenTheScoreIsBelowTheThreshold() public {
+        talent.setScore(threshold - 1);
+        bool ret = validator.isValidDiscountRegistration(userA, "");
+        assertFalse(ret);
+    }
+}

test/discounts/TalenProtocolDiscountValidator/SetThreshold.t.sol

@@ -0,0 +1,19 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Ownable} from "solady/auth/Ownable.sol";
+import {TalentProtocolDiscountValidatorBase} from "./TalentProtocolDiscountValidatorBase.t.sol";
+
+contract SetThreshold is TalentProtocolDiscountValidatorBase {
+    function test_reverts_whenCalledByNonOwner() public {
+        vm.prank(userA);
+        vm.expectRevert(abi.encodeWithSelector(Ownable.Unauthorized.selector));
+        validator.setThreshold(0);
+    }
+
+    function test_allowsOwnerToSetThreshold() public {
+        vm.prank(owner);
+        validator.setThreshold(1);
+        assertEq(1, validator.threshold());
+    }
+}

test/discounts/TalenProtocolDiscountValidator/TalentProtocolDiscountValidatorBase.t.sol

@@ -0,0 +1,21 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Test} from "forge-std/Test.sol";
+import {TalentProtocolDiscountValidator} from "src/L2/discounts/TalentProtocolDiscountValidator.sol";
+import {MockBuilderScorePassport} from "test/mocks/MockBuilderScorePassport.sol";
+
+contract TalentProtocolDiscountValidatorBase is Test {
+    MockBuilderScorePassport talent;
+    TalentProtocolDiscountValidator validator;
+    address owner = makeAddr("owner");
+    address userA = makeAddr("userA");
+    address userB = makeAddr("userB");
+
+    uint256 threshold = 50;
+
+    function setUp() public {
+        talent = new MockBuilderScorePassport(threshold);
+        validator = new TalentProtocolDiscountValidator(owner, address(talent), threshold);
+    }
+}

test/mocks/MockBuilderScorePassport.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {TalentProtocol} from "src/L2/discounts/TalentProtocolDiscountValidator.sol";
+
+contract MockBuilderScorePassport is TalentProtocol {
+    uint256 score;
+
+    constructor(uint256 score_) {
+        score = score_;
+    }
+
+    function getScoreByAddress(address) external view returns (uint256) {
+        return score;
+    }
+
+    function setScore(uint256 score_) external {
+        score = score_;
+    }
+}