feat(nfts): kbw party ticket smart contracts

packages/nfts/contracts/party-ticket/TaikoPartyTicket.sol

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: MIT
+// Compatible with OpenZeppelin Contracts ^5.0.0
+pragma solidity ^0.8.24;
+
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol";
+import "@openzeppelin/contracts/access/AccessControl.sol";
+import "@openzeppelin/contracts/utils/Strings.sol";
+import { ERC721EnumerableUpgradeable } from
+    "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
+import { AccessControlUpgradeable } from
+    "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import { PausableUpgradeable } from
+    "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
+import { IMinimalBlacklist } from "@taiko/blacklist/IMinimalBlacklist.sol";
+
+/// @title TaikoPartyTicket
+/// @dev ERC-721 KBW Raffle & Party Tickets
+/// @custom:security-contact security@taiko.xyz
+contract TaikoPartyTicket is
+    ERC721EnumerableUpgradeable,
+    PausableUpgradeable,
+    AccessControlUpgradeable
+{
+    event BlacklistUpdated(address _blacklist);
+
+    /// @notice Owner role
+    bytes32 public constant OWNER_ROLE = keccak256("OWNER_ROLE");
+    /// @notice Mint fee
+    uint256 public mintFee;
+    /// @notice Mint active flag
+    bool public mintActive;
+    /// @notice Token ID to winner mapping
+    mapping(uint256 tokenId => bool isWinner) public winners;
+    /// @notice Base URI required to interact with IPFS
+    string public baseURI;
+    /// @notice Winner base URI required to interact with IPFS
+    string public winnerBaseURI;
+    /// @notice Payout address
+    address public payoutAddress;
+    /// @notice Internal counter for token IDs
+    uint256 private _nextTokenId;
+    /// @notice Blackist address
+    IMinimalBlacklist public blacklist;
+    /// @notice Gap for upgrade safety
+    uint256[47] private __gap;
+
+    error INSUFFICIENT_MINT_FEE();
+    error CANNOT_REVOKE_NON_WINNER();
+    error ADDRESS_BLACKLISTED();
+
+    /// @notice Contract initializer
+    /// @param _payoutAddress The address to receive mint fees
+    /// @param _mintFee The fee to mint a ticket
+    /// @param _baseURI Base URI for the token metadata pre-raffle
+    /// @param _blacklistAddress The address of the blacklist contract
+    function initialize(
+        address _payoutAddress,
+        uint256 _mintFee,
+        string memory _baseURI,
+        IMinimalBlacklist _blacklistAddress
+    )
+        external
+        initializer
+    {
+        __ERC721_init("TaikoPartyTicket", "TPT");
+
+        mintFee = _mintFee;
+        baseURI = _baseURI;
+        payoutAddress = _payoutAddress;
+        blacklist = _blacklistAddress;
+
+        _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());
+        _grantRole(OWNER_ROLE, _payoutAddress);
+    }
+
+    /// @notice Update the blacklist address
+    /// @param _blacklist The new blacklist address
+    function updateBlacklist(IMinimalBlacklist _blacklist) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        blacklist = _blacklist;
+        emit BlacklistUpdated(address(_blacklist));
+    }
+
+    /// @notice Get individual token's URI
+    /// @param tokenId The token ID
+    /// @return The token URI
+    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
+        if (winners[tokenId]) {
+            return string(abi.encodePacked(winnerBaseURI, Strings.toString(tokenId)));
+        }
+        return string(abi.encodePacked(baseURI, Strings.toString(tokenId)));
+    }
+
+    /// @notice Checks if a tokenId is a winner
+    /// @param tokenId The token ID
+    /// @return Whether the token is a winner
+    function isWinner(uint256 tokenId) public view returns (bool) {
+        return winners[tokenId];
+    }
+
+    /// @notice Checks if an address is a winner
+    /// @param minter The address to check
+    /// @return Whether the address is a winner
+    function isWinner(address minter) public view returns (bool) {
+        for (uint256 i = 0; i < balanceOf(minter); i++) {
+            if (winners[tokenOfOwnerByIndex(minter, i)]) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// @notice Set the winners and update the metadata
+    /// @param _winners The list of winners
+    /// @param _winnerBaseURI Base URI for the winners tokens
+    /// @param _loserBaseURI Base URI for the losers tokens
+    function setWinners(
+        uint256[] calldata _winners,
+        string memory _winnerBaseURI,
+        string memory _loserBaseURI
+    )
+        external
+        whenNotPaused
+        onlyRole(DEFAULT_ADMIN_ROLE)
+    {
+        winnerBaseURI = _winnerBaseURI;
+        baseURI = _loserBaseURI;
+        for (uint256 i = 0; i < _winners.length; i++) {
+            winners[_winners[i]] = true;
+        }
+        pause();
+    }
+
+    /// @notice Set the base URI
+    /// @param _baseURI The new base URI
+    function setBaseURI(string memory _baseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        baseURI = _baseURI;
+    }
+
+    /// @notice Set the winner base URI
+    /// @param _winnerBaseURI The new winner base URI
+    function setWinnerURI(string memory _winnerBaseURI) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        winnerBaseURI = _winnerBaseURI;
+    }
+
+    /// @notice Mint a raffle ticket
+    /// @dev Requires a fee to mint
+    /// @dev Requires the contract to not be paused
+    function mint() external payable whenNotPaused {
+        if (blacklist.isBlacklisted(_msgSender())) revert ADDRESS_BLACKLISTED();
+        if (msg.value < mintFee) revert INSUFFICIENT_MINT_FEE();
+        uint256 tokenId = _nextTokenId++;
+        _safeMint(msg.sender, tokenId);
+    }
+
+    /// @notice Mint a raffle ticket
+    /// @param to The address to mint to
+    /// @dev Requires the contract to not be paused
+    /// @dev Can only be called by the admin
+    function mint(address to) public whenNotPaused onlyRole(DEFAULT_ADMIN_ROLE) {
+        if (blacklist.isBlacklisted(to)) revert ADDRESS_BLACKLISTED();
+        uint256 tokenId = _nextTokenId++;
+        _safeMint(to, tokenId);
+    }
+
+    /// @notice Revoke a winner and replace with a new winner
+    /// @param revokeId The ID of the winner to revoke
+    /// @param newWinnerId The ID of the new winner
+    function revokeAndReplaceWinner(
+        uint256 revokeId,
+        uint256 newWinnerId
+    )
+        external
+        whenPaused
+        onlyRole(DEFAULT_ADMIN_ROLE)
+    {
+        if (!winners[newWinnerId]) revert CANNOT_REVOKE_NON_WINNER();
+        winners[revokeId] = false;
+        winners[newWinnerId] = true;
+    }
+
+    /// @notice Pause the contract
+    /// @dev Can only be called by the admin
+    function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
+        _pause();
+    }
+
+    /// @notice Unpause the contract
+    /// @dev Can only be called by the admin
+    function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
+        _unpause();
+    }
+
+    /// @notice Withdraw the contract balance
+    /// @dev Can only be called by the admin
+    /// @dev Requires the contract to be paused
+    function withdraw() external whenPaused onlyRole(DEFAULT_ADMIN_ROLE) {
+        payable(payoutAddress).transfer(address(this).balance);
+    }
+
+    /// @notice supportsInterface implementation
+    /// @param interfaceId The interface ID
+    /// @return Whether the interface is supported
+    function supportsInterface(bytes4 interfaceId)
+        public
+        view
+        override(ERC721EnumerableUpgradeable, AccessControlUpgradeable)
+        returns (bool)
+    {
+        return super.supportsInterface(interfaceId);
+    }
+}

packages/nfts/script/party-ticket/sol/Deploy.s.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import { UtilsScript } from "./Utils.s.sol";
+import { Script, console } from "forge-std/src/Script.sol";
+import { Merkle } from "murky/Merkle.sol";
+import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import { TaikoPartyTicket } from "../../../contracts/party-ticket/TaikoPartyTicket.sol";
+import { IMinimalBlacklist } from "@taiko/blacklist/IMinimalBlacklist.sol";
+
+contract DeployScript is Script {
+    UtilsScript public utils;
+    string public jsonLocation;
+    uint256 public deployerPrivateKey;
+    address public deployerAddress;
+
+    // Hardhat Testnet Values
+    address owner = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
+    string baseURI =
+        "https://taikonfts.4everland.link/ipfs/bafybeierqzehlrqeqqeb6fwmil4dj3ij2p6exgoj4lysl53fsxwob6wbdy";
+    IMinimalBlacklist blacklist = IMinimalBlacklist(0xe61E9034b5633977eC98E302b33e321e8140F105);
+
+    uint256 mintFee = 0.1 ether;
+    address payoutWallet = 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266;
+
+    function setUp() public {
+        utils = new UtilsScript();
+        utils.setUp();
+
+        jsonLocation = utils.getContractJsonLocation();
+        deployerPrivateKey = utils.getPrivateKey();
+        deployerAddress = utils.getAddress();
+    }
+
+    function run() public {
+        string memory jsonRoot = "root";
+
+        require(owner != address(0), "Owner must be specified");
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        // deploy token with empty root
+        address impl = address(new TaikoPartyTicket());
+        address proxy = address(
+            new ERC1967Proxy(
+                impl,
+                abi.encodeCall(
+                    TaikoPartyTicket.initialize, (payoutWallet, mintFee, baseURI, blacklist)
+                )
+            )
+        );
+
+        TaikoPartyTicket token = TaikoPartyTicket(proxy);
+
+        console.log("Token Base URI:", baseURI);
+        console.log("Deployed TaikoPartyTicket to:", address(token));
+
+        string memory finalJson = vm.serializeAddress(jsonRoot, "TaikoPartyTicket", address(token));
+        vm.writeJson(finalJson, jsonLocation);
+
+        vm.stopBroadcast();
+    }
+}

packages/nfts/script/party-ticket/sol/Utils.s.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import { Script, console } from "forge-std/src/Script.sol";
+import "forge-std/src/StdJson.sol";
+import { IMinimalBlacklist } from "@taiko/blacklist/IMinimalBlacklist.sol";
+import { MockBlacklist } from "../../../test/util/Blacklist.sol";
+
+contract UtilsScript is Script {
+    using stdJson for string;
+
+    address public nounsTokenAddress;
+
+    uint256 public chainId;
+
+    string public lowercaseNetworkKey;
+    string public uppercaseNetworkKey;
+
+    function setUp() public {
+        // load all network configs
+        chainId = block.chainid;
+
+        if (chainId == 31_337) {
+            lowercaseNetworkKey = "localhost";
+            uppercaseNetworkKey = "LOCALHOST";
+        } else if (chainId == 17_000) {
+            lowercaseNetworkKey = "holesky";
+            uppercaseNetworkKey = "HOLESKY";
+        } else if (chainId == 167_001) {
+            lowercaseNetworkKey = "devnet";
+            uppercaseNetworkKey = "DEVNET";
+        } else if (chainId == 11_155_111) {
+            lowercaseNetworkKey = "sepolia";
+            uppercaseNetworkKey = "SEPOLIA";
+        } else if (chainId == 167_008) {
+            lowercaseNetworkKey = "katla";
+            uppercaseNetworkKey = "KATLA";
+        } else if (chainId == 167_000) {
+            lowercaseNetworkKey = "mainnet";
+            uppercaseNetworkKey = "MAINNET";
+        } else if (chainId == 167_009) {
+            lowercaseNetworkKey = "hekla";
+            uppercaseNetworkKey = "HEKLA";
+        } else {
+            revert("Unsupported chainId");
+        }
+    }
+
+    function getPrivateKey() public view returns (uint256) {
+        string memory lookupKey = string.concat(uppercaseNetworkKey, "_PRIVATE_KEY");
+        return vm.envUint(lookupKey);
+    }
+
+    function getAddress() public view returns (address) {
+        string memory lookupKey = string.concat(uppercaseNetworkKey, "_ADDRESS");
+        return vm.envAddress(lookupKey);
+    }
+
+    function getContractJsonLocation() public view returns (string memory) {
+        string memory root = vm.projectRoot();
+        return
+            string.concat(root, "/deployments/trailblazers-badges/", lowercaseNetworkKey, ".json");
+    }
+
+    function getBlacklist() public view returns (IMinimalBlacklist blacklistAddress) {
+        if (block.chainid == 167_000) {
+            // mainnet blacklist address
+            blacklistAddress = IMinimalBlacklist(vm.envAddress("BLACKLIST_ADDRESS"));
+        } else {
+            // deploy a mock blacklist otherwise
+            blacklistAddress = IMinimalBlacklist(0xbdEd0D2bf404bdcBa897a74E6657f1f12e5C6fb6);
+        }
+
+        return blacklistAddress;
+    }
+
+    function run() public { }
+}