@gooddollar/goodcollective-contracts 1.0.0

package/README.md

@@ -0,0 +1 @@
+# contracts

package/contracts/DirectPayments/DirectPaymentsFactory.sol

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+// import the DirectPayments contract
+import "./DirectPaymentsPool.sol";
+import "./ProvableNFT.sol";
+import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+import "hardhat/console.sol";
+
+contract DirectPaymentsFactory is AccessControlUpgradeable, UUPSUpgradeable {
+    error NOT_PROJECT_OWNER();
+
+    event PoolCreated(address indexed pool, string indexed projectId, string ipfs, uint32 indexed nftType);
+    event PoolDetailsChanged(address indexed pool, string ipfs);
+    event PoolVerifiedChanged(address indexed pool, bool isVerified);
+    event UpdatedImpl(address indexed impl);
+
+    struct PoolRegistry {
+        string ipfs;
+        bool isVerified;
+        string projectId;
+    }
+
+    address public impl;
+    ProvableNFT public nft;
+    uint32 public nextNftType;
+
+    mapping(address => PoolRegistry) public registry;
+    mapping(bytes32 => DirectPaymentsPool) public projectIdToControlPool;
+
+    modifier onlyProjectOwnerOrNon(string memory projectId) {
+        DirectPaymentsPool controlPool = projectIdToControlPool[keccak256(bytes(projectId))];
+        console.log("control:%s sender:%s %s", address(controlPool), msg.sender);
+        // console.log("result %s", controlPool.hasRole(controlPool.DEFAULT_ADMIN_ROLE(), msg.sender));
+        if (address(controlPool) != address(0)) {
+            if (controlPool.hasRole(controlPool.DEFAULT_ADMIN_ROLE(), msg.sender) == false) {
+                revert NOT_PROJECT_OWNER();
+            }
+        }
+        _;
+    }
+
+    modifier onlyProjectOwnerByPool(DirectPaymentsPool pool) {
+        string memory projectId = registry[address(pool)].projectId;
+        DirectPaymentsPool controlPool = projectIdToControlPool[keccak256(bytes(projectId))];
+        if (controlPool.hasRole(controlPool.DEFAULT_ADMIN_ROLE(), msg.sender) == false) {
+            revert NOT_PROJECT_OWNER();
+        }
+
+        _;
+    }
+
+    function _authorizeUpgrade(address _impl) internal virtual override onlyRole(DEFAULT_ADMIN_ROLE) {}
+
+    function initialize(address _owner, address _dpimpl, address _nftimpl) external initializer {
+        nextNftType = 1;
+        impl = _dpimpl;
+        bytes memory initCall = abi.encodeWithSelector(ProvableNFT.initialize.selector, "DirectPayments NFT", "DPNFT");
+        nft = ProvableNFT(address(new ERC1967Proxy(_nftimpl, initCall)));
+
+        nft.grantRole(DEFAULT_ADMIN_ROLE, _owner);
+        _setupRole(DEFAULT_ADMIN_ROLE, _owner);
+    }
+
+    function createPool(
+        string memory _projectId,
+        string memory _ipfs,
+        DirectPaymentsPool.PoolSettings memory _settings,
+        DirectPaymentsPool.SafetyLimits memory _limits
+    ) external onlyProjectOwnerOrNon(_projectId) returns (DirectPaymentsPool pool) {
+        //TODO: add check if msg.sender is whitelisted
+
+        _settings.nftType = nextNftType;
+        bytes memory initCall = abi.encodeWithSelector(DirectPaymentsPool.initialize.selector, nft, _settings, _limits);
+        pool = DirectPaymentsPool(address(new ERC1967Proxy(impl, initCall)));
+
+        nft.grantRole(nft.getManagerRole(nextNftType), _settings.manager);
+        nft.grantRole(nft.getManagerRole(nextNftType), address(pool));
+        pool.grantRole(pool.MINTER_ROLE(), _settings.manager);
+
+        projectIdToControlPool[keccak256(bytes(_projectId))] = pool;
+        registry[address(pool)].ipfs = _ipfs;
+        registry[address(pool)].projectId = _projectId;
+
+        pool.renounceRole(DEFAULT_ADMIN_ROLE, address(this));
+        emit PoolCreated(address(pool), _projectId, _ipfs, nextNftType);
+
+        nextNftType++;
+    }
+
+    function changePoolDetails(DirectPaymentsPool _pool, string memory _ipfs) external onlyProjectOwnerByPool(_pool) {
+        registry[address(_pool)].ipfs = _ipfs;
+        emit PoolDetailsChanged(address(_pool), _ipfs);
+    }
+
+    function setVerified(DirectPaymentsPool _pool, bool _isVerified) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        registry[address(_pool)].isVerified = _isVerified;
+        emit PoolVerifiedChanged(address(_pool), _isVerified);
+    }
+
+    function updateImpl(address _impl) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        impl = _impl;
+        emit UpdatedImpl(_impl);
+    }
+}

package/contracts/DirectPayments/DirectPaymentsPool.sol

@@ -0,0 +1,333 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8;
+import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import { IERC721Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
+import { SafeERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import { IERC721ReceiverUpgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol";
+
+import { ProvableNFT } from "./ProvableNFT.sol";
+import { DirectPaymentsFactory } from "./DirectPaymentsFactory.sol";
+
+interface IMembersValidator {
+    function isMemberValid(
+        address pool,
+        address operator,
+        address member,
+        bytes memory extraData
+    ) external returns (bool);
+}
+
+interface IIdentityV2 {
+    function getWhitelistedRoot(address member) external returns (address);
+}
+
+/**
+ - optional members validator (but need atleast uniqueness or members)
+ - anyone can claim an nfttype
+ - project id at the registery?
+ - factory -> register the pool, claim nfttype, deploy pool
+ - events
+ */
+contract DirectPaymentsPool is IERC721ReceiverUpgradeable, AccessControlUpgradeable, UUPSUpgradeable {
+    using SafeERC20Upgradeable for IERC20Upgradeable;
+    error NOT_MANAGER();
+    error ALREADY_CLAIMED(uint256);
+    error NFT_MISSING(uint256);
+    error NOT_MEMBER(address);
+    error NOT_WHITELISTED(address);
+    error OVER_MEMBER_LIMITS(address);
+    error OVER_GLOBAL_LIMITS();
+    error UNSUPPORTED_NFT();
+    error NO_BALANCE();
+
+    bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
+    bytes32 public constant MINTER_ROLE = keccak256("MINTER");
+
+    event PoolSettingsChanged(PoolSettings settings);
+    event PoolLimitsChanged(SafetyLimits limits);
+    event MemberAdded(address member);
+    event MemberRemoved(address member);
+    event RewardClaimed(uint256 indexed tokenId, uint256 totalRewards);
+
+    // Define functions
+    struct PoolSettings {
+        uint32 nftType;
+        uint16[] validEvents;
+        uint128[] rewardPerEvent;
+        address manager;
+        IMembersValidator membersValidator;
+        IIdentityV2 uniqunessValidator;
+        IERC20Upgradeable rewardToken;
+    }
+
+    struct SafetyLimits {
+        uint maxTotalPerMonth;
+        uint256 maxMemberPerMonth;
+        uint256 maxMemberPerDay;
+    }
+
+    struct LimitsData {
+        uint128 daily;
+        uint128 monthly;
+        uint128 total;
+        uint64 lastReward;
+        uint64 lastMonth;
+    }
+
+    PoolSettings public settings;
+    SafetyLimits public limits;
+    ProvableNFT public nft;
+
+    mapping(uint256 => bool) public claimedNfts;
+    mapping(address => bool) public members;
+    mapping(address => LimitsData) public memberLimits;
+    LimitsData public globalLimits;
+    address public createdBy;
+
+    /**
+     * @dev Authorizes an upgrade for the implementation contract.
+     * @param impl The address of the new implementation contract.
+     */
+    function _authorizeUpgrade(address impl) internal virtual override {}
+
+    /**
+     * @dev Initializes the contract with the given settings and limits.
+     * @param _nft The ProvableNFT contract address.
+     * @param _settings The PoolSettings struct containing pool settings.
+     * @param _limits The SafetyLimits struct containing safety limits.
+     */
+    function initialize(
+        ProvableNFT _nft,
+        PoolSettings memory _settings,
+        SafetyLimits memory _limits
+    ) external initializer {
+        uint l = 5;
+        createdBy = msg.sender;
+        settings = _settings;
+        limits = _limits;
+        nft = _nft;
+        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+        _setupRole(DEFAULT_ADMIN_ROLE, _settings.manager);
+    }
+
+    function upgradeToLatest(bytes memory data) external payable virtual onlyProxy {
+        address impl = DirectPaymentsFactory(createdBy).impl();
+        _authorizeUpgrade(impl);
+        _upgradeToAndCallUUPS(impl, data, false);
+    }
+
+    /**
+     * @dev Claims rewards for the specified NFT ID.
+     * @param _nftId The ID of the NFT to claim rewards for.
+     */
+    function claim(uint256 _nftId) external {
+        claim(_nftId, nft.getNFTData(_nftId));
+    }
+
+    /**
+     * @dev Claims rewards for a given NFT ID and its associated data.
+     * @param _nftId The ID of the NFT to claim rewards for.
+     * @param _data The associated data for the NFT.
+     * Emits a {ALREADY_CLAIMED} error if the NFT has already been claimed.
+     * Emits a {NFT_MISSING} error if the NFT is not owned by this contract.
+     */
+
+    function claim(uint256 _nftId, ProvableNFT.NFTData memory _data) public {
+        nft.proveNFTData(_nftId, _data);
+        if (claimedNfts[_nftId]) revert ALREADY_CLAIMED(_nftId);
+
+        // TODO: should pool own the NFTs?
+        // if (settings.collectNfts && nft.ownerOf(_nftId) != address(this)) revert NFT_MISSING(_nftId);
+
+        _claim(_nftId, _data);
+    }
+
+    /**
+     * @dev Claims rewards for the specified NFT ID.
+     * @param _nftId The ID of the NFT to claim rewards for.
+     * @param _data The NFTData struct containing data about the NFT.
+     */
+    function _claim(uint256 _nftId, ProvableNFT.NFTData memory _data) internal {
+        claimedNfts[_nftId] = true;
+        uint totalRewards;
+        uint rewardsBalance = settings.rewardToken.balanceOf(address(this));
+
+        for (uint256 i = 0; i < _data.events.length; i++) {
+            uint128 reward = _eventReward(_data.events[i].subtype);
+            if (reward > 0) {
+                totalRewards += reward * _data.events[i].quantity;
+                if (totalRewards > rewardsBalance) revert NO_BALANCE();
+                rewardsBalance -= totalRewards;
+                _sendReward(_data.events[i].contributers, uint128(reward * _data.events[i].quantity));
+            }
+        }
+
+        emit RewardClaimed(_nftId, totalRewards);
+    }
+
+    /**
+     * @dev Returns the reward amount for the specified event type.
+     * @param _eventType The type of the event to get the reward for.
+     * @return reward amount for the specified event type.
+     */
+    function _eventReward(uint16 _eventType) internal view returns (uint128 reward) {
+        for (uint i = 0; i < settings.validEvents.length; i++) {
+            if (_eventType == settings.validEvents[i]) return settings.rewardPerEvent[i];
+        }
+        return 0;
+    }
+
+    /**
+     * @dev Sends rewards to the specified recipients.
+     * @param recipients The addresses of the recipients to send rewards to.
+     * @param reward The total amount of rewards to send.
+     */
+    function _sendReward(address[] memory recipients, uint128 reward) internal {
+        uint128 perReward = uint128(reward / recipients.length);
+        for (uint i = 0; i < recipients.length; i++) {
+            _enforceAndUpdateMemberLimits(recipients[i], perReward);
+            settings.rewardToken.safeTransfer(recipients[i], perReward);
+        }
+        _enforceAndUpdateGlobalLimits(reward);
+    }
+
+    /**
+     * @dev Enforces and updates the reward limits for the specified member.
+     * @param member The address of the member to enforce and update limits for.
+     * @param reward The amount of rewards to enforce and update limits for.
+     */
+    function _enforceAndUpdateMemberLimits(address member, uint128 reward) internal {
+        if (members[member] == false) revert NOT_MEMBER(member);
+
+        uint64 curMonth = _month();
+        if (memberLimits[member].lastReward + 60 * 60 * 24 < block.timestamp) //more than a day passed since last reward
+        {
+            memberLimits[member].daily = reward;
+        } else {
+            memberLimits[member].daily += reward;
+        }
+
+        if (memberLimits[member].lastMonth < curMonth) //month switched
+        {
+            memberLimits[member].monthly = reward;
+        } else {
+            memberLimits[member].monthly += reward;
+        }
+
+        memberLimits[member].total += reward;
+        memberLimits[member].lastReward = uint64(block.timestamp);
+        memberLimits[member].lastMonth = curMonth;
+
+        if (
+            memberLimits[member].daily > limits.maxMemberPerDay ||
+            memberLimits[member].monthly > limits.maxMemberPerMonth
+        ) revert OVER_MEMBER_LIMITS(member);
+    }
+
+    /**
+     * @dev Enforces and updates the global reward limits.
+     * @param reward The amount of rewards to enforce and update limits for.
+     */
+    function _enforceAndUpdateGlobalLimits(uint128 reward) internal {
+        uint64 curMonth = _month();
+
+        if (globalLimits.lastReward + 60 * 60 * 24 < block.timestamp) //more than a day passed since last reward
+        {
+            globalLimits.daily = reward;
+        } else {
+            globalLimits.daily += reward;
+        }
+
+        if (globalLimits.lastMonth < curMonth) //month switched
+        {
+            globalLimits.monthly = reward;
+        } else {
+            globalLimits.monthly += reward;
+        }
+
+        globalLimits.total += reward;
+        globalLimits.lastReward = uint64(block.timestamp);
+        globalLimits.lastMonth = curMonth;
+
+        if (globalLimits.monthly > limits.maxTotalPerMonth) revert OVER_GLOBAL_LIMITS();
+    }
+
+    /**
+     * @dev Returns the current month.
+     * @return month current month as a uint64 value.
+     */
+    function _month() internal view returns (uint64 month) {
+        return uint64(block.timestamp / (60 * 60 * 24 * 30));
+    }
+
+    /**
+     * @dev Adds a member to the contract.
+     * @param member The address of the member to add.
+     * @param extraData Additional data to validate the member.
+     */
+
+    function addMember(address member, bytes memory extraData) external {
+        if (address(settings.uniqunessValidator) != address(0)) {
+            address rootAddress = settings.uniqunessValidator.getWhitelistedRoot(member);
+            if (rootAddress == address(0)) revert NOT_WHITELISTED(member);
+        }
+
+        if (address(settings.membersValidator) != address(0)) {
+            if (settings.membersValidator.isMemberValid(address(this), msg.sender, member, extraData) == false) {
+                revert NOT_MEMBER(member);
+            }
+        } else {
+            // if no members validator then only admin can add members
+            if (hasRole(DEFAULT_ADMIN_ROLE, msg.sender) == false) revert NOT_MANAGER();
+        }
+
+        members[member] = true;
+        emit MemberAdded(member);
+    }
+
+    /**
+     * @dev Removes a member from the contract.
+     * @param member The address of the member to remove.
+     */
+    function removeMember(address member) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        members[member] = false;
+        emit MemberRemoved(member);
+    }
+
+    function mintNFT(address _to, ProvableNFT.NFTData memory _nftData, bool withClaim) external onlyRole(MINTER_ROLE) {
+        uint nftId = nft.mintPermissioned(_to, _nftData, true, "");
+        if (withClaim) {
+            claim(nftId, _nftData);
+        }
+    }
+
+    /**
+     * @dev Receives an ERC721 token and triggers a claim for rewards.
+     * @param operator The address of the operator that sent the token.
+     * @param from The address of the sender that sent the token.
+     * @param tokenId The ID of the token received.
+     * @param data Additional data to trigger a claim for rewards.
+     * @return A bytes4 value indicating success or failure.
+     */
+    function onERC721Received(
+        address operator,
+        address from,
+        uint256 tokenId,
+        bytes calldata data
+    ) external returns (bytes4) {
+        // bool triggerClaim;
+        // if (data.length > 0) (triggerClaim) = abi.decode(data, (bool));
+        // if (triggerClaim) {
+        //   ProvableNFT.NFTData memory nftData = nft.getNFTData(tokenId);
+        //   if (nftData.nftType > 0) // check the nftData is actually stored on-chain, otherwise claim will not work
+        //   {
+        //     claim(tokenId, nftData);
+        //   }
+        // }
+        ProvableNFT.NFTData memory nftData = nft.getNFTData(tokenId);
+        if (nftData.nftType != settings.nftType) revert UNSUPPORTED_NFT();
+        return DirectPaymentsPool.onERC721Received.selector;
+    }
+}

package/contracts/DirectPayments/ProvableNFT.sol

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import { ERC721Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
+import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import { StringsUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
+import { UUPSUpgradeable } from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+/**
+    An NFT that can store data related to actions, the data is stored on-chain or as hash of the content that can later be proved.
+ */
+contract ProvableNFT is ERC721Upgradeable, AccessControlUpgradeable, UUPSUpgradeable {
+    error BAD_DATAHASH(bytes32 dataHash, bytes32 tokenId);
+    error NOT_MINTER();
+    error NOT_MANAGER(uint32);
+    error BAD_NFTTYPE();
+
+    bytes32 public constant MINTER_ROLE = keccak256(abi.encodePacked("MINTER"));
+    bytes16 private constant _SYMBOLS = "0123456789abcdef";
+
+    struct EventData {
+        uint16 subtype;
+        uint32 timestamp;
+        uint256 quantity;
+        string eventUri; //extra data related to event
+        address[] contributers;
+    }
+
+    struct NFTData {
+        uint32 nftType; //should be non zero
+        uint16 version;
+        string nftUri; //extra data related to nft
+        EventData[] events;
+    }
+
+    mapping(uint256 => NFTData) internal nftDatas;
+
+    function initialize(string memory _name, string memory _symbol) external initializer {
+        __ERC721_init(_name, _symbol);
+        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    function _authorizeUpgrade(address newimpl) internal virtual override onlyManager(0) {}
+
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(AccessControlUpgradeable, ERC721Upgradeable) returns (bool) {
+        return super.supportsInterface(interfaceId);
+    }
+
+    modifier onlyManager(uint32 nftType) {
+        if (
+            ((nftType > 0 && hasRole(getManagerRole(nftType), msg.sender)) ||
+                hasRole(DEFAULT_ADMIN_ROLE, msg.sender)) == false
+        ) {
+            revert NOT_MANAGER(nftType);
+        }
+        _;
+    }
+
+    /**
+     * @dev Mint a new NFT with the given URI and data hash.
+     *
+     * Requirements:
+     * - The caller must have the `Manager` role.
+     *
+     * Emits a {Transfer} event and a {URI} event.
+     *
+     * @param _to The address that will receive the minted NFT.
+     * @param _uri The URI for the NFT's metadata.
+     * @param _nftDataHash The hash of the NFT's data.
+     * @return tokenId ID of the newly minted NFT.
+     */
+    function mint(
+        address _to,
+        string memory _uri,
+        bytes32 _nftDataHash
+    ) public onlyManager(0) returns (uint256 tokenId) {
+        return _mint(_to, _uri, _nftDataHash, ""); //send false in calldata, assuming default receiver is a directpaymentspool. without nft data on chain it will fail.
+    }
+
+    function _mint(
+        address _to,
+        string memory _uri,
+        bytes32 _nftDataHash,
+        bytes memory _callData
+    ) internal returns (uint256 tokenId) {
+        tokenId = uint256(_nftDataHash);
+        nftDatas[tokenId].nftUri = _uri;
+        _safeMint(_to, tokenId, _callData);
+    }
+
+    /**
+     * @dev Mint a new permissioned NFT with the given data.
+     *
+     * This function is only accessible to users with the `Manager` role for the given NFT type.
+     *
+     * Stores nftData in contract storage if `_withStore` is true.
+     *
+     * @param _to The address that will receive the minted NFT.
+     * @param _nftData The data for the NFT.
+     * @param _withStore Whether or not to store the NFT data in the contract.
+     * @param _callData call data to pass to erc721receiver
+     * @return tokenId ID of the newly minted NFT.
+     */
+    function mintPermissioned(
+        address _to,
+        NFTData memory _nftData,
+        bool _withStore,
+        bytes memory _callData
+    ) external onlyManager(_nftData.nftType) returns (uint256 tokenId) {
+        if (_nftData.nftType == 0) revert BAD_NFTTYPE();
+
+        bytes32 dataHash = keccak256(abi.encode(_nftData));
+        tokenId = uint256(dataHash);
+        if (_withStore) {
+            NFTData storage store = nftDatas[tokenId];
+            store.nftUri = _nftData.nftUri;
+            store.nftType = _nftData.nftType;
+            store.version = _nftData.version;
+            for (uint256 i = 0; i < _nftData.events.length; i++) {
+                store.events.push(_nftData.events[i]);
+            }
+        }
+        _mint(_to, _nftData.nftUri, dataHash, _callData);
+    }
+
+    function proveNFTData(uint256 _tokenId, NFTData memory _nftData) public view returns (NFTData memory data) {
+        _requireMinted(_tokenId);
+        if (keccak256(abi.encode(_nftData)) != bytes32(_tokenId))
+            revert BAD_DATAHASH(keccak256(abi.encode(_nftData)), bytes32(_tokenId));
+
+        return _nftData;
+    }
+
+    function getNFTData(uint256 _tokenId) external view returns (NFTData memory) {
+        return nftDatas[_tokenId];
+    }
+
+    function getNFTEvent(uint256 _tokenId, uint256 _index) external view returns (EventData memory) {
+        return nftDatas[_tokenId].events[_index];
+    }
+
+    function getNFTEvents(uint256 _tokenId) external view returns (EventData[] memory) {
+        return nftDatas[_tokenId].events;
+    }
+
+    function addManager(address _manager, uint32 _nftType) external {
+        grantRole(getManagerRole(_nftType), _manager);
+    }
+
+    function getManagerRole(uint32 _nftType) public pure returns (bytes32 roleHash) {
+        return keccak256(abi.encodePacked("MANAGER_", _nftType));
+    }
+
+    /**
+     * @dev See {IERC721Metadata-tokenURI}.
+     */
+    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
+        _requireMinted(tokenId);
+
+        string memory baseURI = _baseURI();
+        return
+            bytes(baseURI).length > 0
+                ? string(abi.encodePacked(baseURI, nftDatas[tokenId].nftUri))
+                : nftDatas[tokenId].nftUri;
+    }
+
+    /**
+     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
+     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
+     * by default, can be overridden in child contracts.
+     */
+    function _baseURI() internal view virtual override returns (string memory) {
+        return "";
+    }
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@gooddollar/goodcollective-contracts",
+  "packageManager": "yarn@3.2.1",
+  "version": "1.0.0",
+  "license": "MIT",
+  "types": "./typechain-types/index.ts",
+  "files": [
+    "contracts",
+    "typechain-types",
+    "releases"
+  ],
+  "devDependencies": {
+    "@gooddollar/goodprotocol": "file:.yalc/@gooddollar/goodprotocol",
+    "@nomicfoundation/hardhat-chai-matchers": "^1.0.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
+    "@nomicfoundation/hardhat-toolbox": "2.*",
+    "@nomicfoundation/hardhat-verify": "^1.0.1",
+    "@nomiclabs/hardhat-ethers": "^2.0.0",
+    "@nomiclabs/hardhat-etherscan": "^3.0.0",
+    "@openzeppelin/contracts": "^4.9.2",
+    "@openzeppelin/contracts-upgradeable": "4.8.3",
+    "@openzeppelin/hardhat-upgrades": "1.20.0",
+    "@superfluid-finance/ethereum-contracts": "^1.7.0",
+    "@typechain/ethers-v5": "^10.1.0",
+    "@types/chai": "^4.2.0",
+    "@types/mocha": ">=9.1.0",
+    "@types/prettier": "^2",
+    "@typescript-eslint/eslint-plugin": "^5.60.0",
+    "chai": "^4.2.0",
+    "dotenv": "^16.3.1",
+    "hardhat": "2.14.*",
+    "hardhat-abi-exporter": "^2.10.1",
+    "hardhat-contract-sizer": "^2.10.0",
+    "hardhat-deploy": "^0.11.31",
+    "hardhat-gas-reporter": "^1.0.8",
+    "prettier": "^2.8.8",
+    "prettier-plugin-solidity": "^1.1.3",
+    "solhint-plugin-prettier": "^0.0.5",
+    "solidity-coverage": "^0.8.1",
+    "typechain": "^8.1.0",
+    "typescript": "^5.1.3"
+  },
+  "scripts": {
+    "compile": "npx hardhat compile",
+    "clean": "npx hardhat clean",
+    "solhint": "solhint ./contracts/**/*.sol",
+    "format": "yarn prettier -w ./test/**/*.ts ./contracts/**/*.sol",
+    "format:check": "yarn prettier -c ./test/**/*.ts ./contracts/**/*.sol",
+    "lint:ts": "eslint scripts/ test/ --ext=ts",
+    "lint:sol": "solhint 'contracts/**/*.sol'",
+    "lint": "npm run lint:sol && npm run lint:ts",
+    "lint:fix": "npm run lint:sol:fix && npm run lint:ts:fix",
+    "lint:ts:fix": "eslint scripts/ test/ --ext=ts --fix",
+    "lint:sol:fix": "solhint 'contracts/**/*.sol' --fix",
+    "test": "npx hardhat test",
+    "test:coverage": "npx hardhat coverage",
+    "deploy": "hardhat deploy --export-all ./releases/deployment.json"
+  }
+}