【LocalNouns】仕上げ

contract/contracts/LocalNounsToken.sol

@@ -18,27 +18,38 @@ contract LocalNounsToken is ProviderTokenA2, ILocalNounsToken {
   IAssetProviderExMint public assetProvider2;
   address public minter;
   mapping(uint256 => uint256[]) public tradePrefecture; // トレード先指定の都道府県
+  mapping(uint256 => address) public tradeAddress; // トレード先指定のアドレス
 
-  address public administratorsAddress; // 運営ウォレット
+  address[] public royaltyAddresses; // ロイヤリティ送信先ウォレット
+  mapping(address => uint256) public royaltyRatio; // ロイヤリティ送信先ウォレットごとの割合
+  uint256 royaltyRatioTotal; // royaltyRatioの合計(割戻用)
+  bool public canSetApproval = false; // setApprovalForAll, approveの可否
+
+  uint256 public tradeRoyalty = 0.003 ether; // P2Pトレードのロイヤリティ
+  uint256 public salesRoyaltyBasisPoint = 1000; // P2Pセールのロイヤリティ、購入価格の10%
+
+  mapping(address => bool) public approveWhiteList; // Approveを許可するアドレスリスト
 
   constructor(
     IAssetProviderExMint _assetProvider,
     address _minter
   ) ProviderTokenA2(_assetProvider, 'Local Nouns', 'Local Nouns') {
-    description = 'Local Nouns Token.';
+    description = 'Local Nouns';
     assetProvider2 = _assetProvider;
-    // mintPrice = 1e13; // 0.001   ※ mintPriceは Minterコントラクトで制御するため使用しない
-    // mintLimit = 5000;            ※ mintLimitは Minterコントラクトで制御するため使用しない
     minter = _minter;
-    administratorsAddress = msg.sender;
+
+    // ロイヤリティ送信先(コンストラクタではデプロイアドレス100%)
+    royaltyAddresses = [msg.sender];
+    royaltyRatio[msg.sender] = 1;
+    royaltyRatioTotal = 1;
   }
 
   function tokenName(uint256 _tokenId) internal pure override returns (string memory) {
     return string(abi.encodePacked('Local Nouns ', _tokenId.toString()));
   }
 
   function tokenURI(uint256 _tokenId) public view override returns (string memory) {
-    require(_tokenId < _nextTokenId(), 'LocalNounsToken.tokenURI: nonexistent token');
+    require(_tokenId < _nextTokenId(), 'nonexistent token');
 
     (string memory svgPart, string memory tag) = assetProvider2.generateSVGPart(_tokenId);
     bytes memory image = bytes(svgPart);
@@ -77,21 +88,25 @@ contract LocalNounsToken is ProviderTokenA2, ILocalNounsToken {
     uint256 _prefectureId,
     uint256 _amount
   ) public virtual returns (uint256 tokenId) {
-    require(msg.sender == minter || msg.sender == owner(), 'Sender is not minter nor owner');
+    require(msg.sender == minter || msg.sender == owner(), 'Invalid sender');
     require(_prefectureId % 100 <= 47, 'Invalid prefectureId');
 
+    // リエントランシー対策のため状態変更を先に実施
+    _safeMint(_to, _amount);
+
+    uint256 startTokenId = _nextTokenId() - _amount;
+
     for (uint256 i = 0; i < _amount; i++) {
-      assetProvider2.mint(_prefectureId, _nextTokenId() + i);
+      assetProvider2.mint(_prefectureId, startTokenId + i);
     }
-    _safeMint(_to, _amount);
     return _nextTokenId() - 1;
   }
 
   function ownerMint(
     address[] memory _to,
     uint256[] memory _prefectureId,
     uint256[] memory _amount
-  ) public onlyOwner returns (uint256 tokenId) {
+  ) external onlyOwner returns (uint256 tokenId) {
     // 引数の整合性チェック
     require(_to.length == _prefectureId.length && _to.length == _amount.length, 'Invalid Arrays length');
 
@@ -101,31 +116,51 @@ contract LocalNounsToken is ProviderTokenA2, ILocalNounsToken {
     return _nextTokenId() - 1;
   }
 
-  function mint() public payable override returns (uint256 tokenId) {
-    revert('Cannot use this function');
+  function mint() public payable override returns (uint256) {
+    revert('Cannot use');
   }
 
-  function setMinter(address _minter) public onlyOwner {
+  function setMinter(address _minter) external onlyOwner {
     minter = _minter;
   }
 
-  function setAdministratorsAddress(address _admin) external onlyOwner {
-    administratorsAddress = _admin;
+  function setCanSetAproval(bool _canSetApproval) external onlyOwner {
+    canSetApproval = _canSetApproval;
+  }
+
+  function setApproveWhiteList(address _address, bool approve) external onlyOwner {
+    approveWhiteList[_address] = approve;
+  }
+
+  function setRoyaltyAddresses(address[] memory _addr, uint256[] memory ratio) external onlyOwner {
+    // 引数の整合性チェック
+    require(_addr.length == ratio.length, 'Invalid Arrays length');
+    royaltyAddresses = _addr;
+    royaltyRatioTotal = 0;
+
+    for (uint256 i = 0; i < _addr.length; i++) {
+      royaltyRatio[_addr[i]] = ratio[i];
+      royaltyRatioTotal += ratio[i];
+    }
   }
 
   /**
    * @param _tokenId the token id for put on the trade list.
    * @param _prefectures prefectures that you want to trade. if you don't want specific prefecture, you don't need to set.
+   * @param _tradeAddress the address only who can trade.
    */
-  function putTradeLocalNoun(uint256 _tokenId, uint256[] memory _prefectures) public {
+  function putTradeLocalNoun(uint256 _tokenId, uint256[] memory _prefectures, address _tradeAddress) public {
     for (uint256 i = 0; i < _prefectures.length; i++) {
       require(_prefectures[i] > 0 && _prefectures[i] <= 47, 'incorrect prefecutre id');
     }
 
     super.putTrade(_tokenId, true);
     tradePrefecture[_tokenId] = _prefectures;
+    if (_tradeAddress != address(0)) {
+      tradeAddress[_tokenId] = _tradeAddress;
+    }
 
-    emit PutTradePrefecture(_tokenId, _prefectures);
+    emit PutTradePrefecture(_tokenId, _prefectures, _tradeAddress);
   }
 
   function getTradePrefectureFor(uint256 _tokenId) public view returns (uint256[] memory) {
@@ -137,11 +172,20 @@ contract LocalNounsToken is ProviderTokenA2, ILocalNounsToken {
 
     uint256[] memory emptyArray;
     tradePrefecture[_tokenId] = emptyArray;
+    tradeAddress[_tokenId] = address(0);
 
     emit CancelTradePrefecture(_tokenId);
   }
 
-  function executeTradeLocalNoun(uint256 _myTokenId, uint256 _targetTokenId) public {
+  function executeTradeLocalNoun(uint256 _myTokenId, uint256 _targetTokenId) public payable {
+    require(msg.value >= tradeRoyalty, 'Insufficial royalty');
+
+    // tradeAddressがある場合はmsg.senderをチェック
+    require(
+      tradeAddress[_targetTokenId] == address(0) || msg.sender == tradeAddress[_targetTokenId],
+      'Limited address can trade'
+    );
+
     // tradePrefectureがない場合は、希望都道府県がないためチェック不要
     if (tradePrefecture[_targetTokenId].length > 0) {
       uint256 myTokenIdPrefecture = assetProvider2.getPrefectureId(_myTokenId);
@@ -156,38 +200,81 @@ contract LocalNounsToken is ProviderTokenA2, ILocalNounsToken {
     }
 
     super.executeTrade(_myTokenId, _targetTokenId);
+    _processTradeRoyalty(msg.value);
+    emit ExecuteTrade(_targetTokenId, ownerOf(_targetTokenId), _myTokenId, ownerOf(_myTokenId));
   }
 
-  function putTrade(uint256 _tokenId, bool _isOnTrade) public override {
-    revert('Cannot use this function');
+  function putTrade(uint256, bool) public pure override {
+    revert('Cannot use');
   }
 
-  function executeTrade(uint256 _myTokenId, uint256 _targetTokenId) public override {
-    revert('Cannot use this function');
+  function executeTrade(uint256, uint256) public pure override {
+    revert('Cannot use');
+  }
+
+  function purchase(uint256 _tokenId, address _buyer, address _facilitator) external payable override {
+    super._purchase(_tokenId, _buyer, _facilitator);
+    emit Purchase(_tokenId, _buyer);
   }
 
   // transfer時はトレード解除
   function _beforeTokenTransfers(address from, address to, uint256 startTokenId, uint256 quantity) internal override {
     uint256[] memory emptyArray;
     tradePrefecture[startTokenId] = emptyArray;
+    tradeAddress[startTokenId] = address(0);
     super._beforeTokenTransfers(from, to, startTokenId, quantity);
   }
 
+  function setTradeRoyalty(uint256 _royalty) external onlyOwner {
+    tradeRoyalty = _royalty;
+  }
+
+  function setSalesRoyaltyBasisPoint(uint256 _bp) external onlyOwner {
+    salesRoyaltyBasisPoint = _bp;
+  }
+
   // pay royalties to admin here
-  function _processRoyalty(uint _salesPrice, uint _tokenId) internal override returns (uint256 royalty) {
-    royalty = (_salesPrice * 50) / 1000; // 5.0%
-    address payable payableTo = payable(administratorsAddress);
-    payableTo.transfer(royalty);
+  function _processRoyalty(uint _salesPrice, uint) internal override returns (uint256 royalty) {
+    // royalty = (_salesPrice * 100) / 1000; // 10.0%
+    royalty = (_salesPrice * salesRoyaltyBasisPoint) / 10000;
+    _sendRoyalty(royalty);
+  }
+
+  // pay royalties to admin here
+  function _processTradeRoyalty(uint _royalty) internal {
+    _sendRoyalty(_royalty);
+  }
+
+  // send royalties to admin and developper
+  function _sendRoyalty(uint _royalty) internal {
+    for (uint256 i = 0; i < royaltyAddresses.length; i++) {
+      _trySendRoyalty(royaltyAddresses[i], (_royalty * royaltyRatio[royaltyAddresses[i]]) / royaltyRatioTotal);
+    }
+  }
+
+  function _trySendRoyalty(address to, uint amount) internal {
+    (bool sent, ) = payable(to).call{ value: amount }('');
+    require(sent, 'Failed to send');
   }
 
   function withdraw() external payable onlyOwner {
-    require(administratorsAddress != address(0), "administratorsAddress shouldn't be 0");
-    (bool sent, ) = payable(administratorsAddress).call{ value: address(this).balance }('');
-    require(sent, 'failed to move fund to administratorsAddress contract');
+    _sendRoyalty(address(this).balance);
   }
 
-  // iLocalNounsTokenでERC721のtotalSupplyを使用したいけど、二重継承でエラーになるので個別関数を準備
+  // 二重継承でエラーになるので個別関数を準備
   function totalSupply2() public view returns (uint256) {
     return super.totalSupply();
   }
+
+  // 誰もがトークンを承認できないようにする
+  function setApprovalForAll(address operator, bool approved) public override {
+    require(canSetApproval || approveWhiteList[operator], 'Not allowed to set approval for all');
+    super.setApprovalForAll(operator, approved);
+  }
+
+  // 特定のトークンの承認も不可能にする
+  function approve(address to, uint256 tokenId) public payable override {
+    require(canSetApproval || approveWhiteList[to], 'Not allowed to approve');
+    super.approve(to, tokenId);
+  }
 }

contract/contracts/localNouns/LocalNounsMinter.sol

@@ -22,11 +22,14 @@ import './interfaces/ILocalNounsToken.sol';
 import '../interfaces/ITokenGate.sol';
 
 contract LocalNounsMinter is Ownable {
+  // Fires when the purchase executed
+  event MintSelectedPrefecture(uint256 prefectureId, uint256 amount, address minter);
+
   ILocalNounsToken public token;
   ITokenGate public immutable tokenGate;
 
-  uint256 public mintPriceForSpecified = 0.003 ether;
-  uint256 public mintPriceForNotSpecified = 0.001 ether;
+  uint256 public mintPriceForSpecified = 0.03 ether;
+  uint256 public mintPriceForNotSpecified = 0.01 ether;
 
   uint256 public mintMax = 1500;
 
@@ -82,14 +85,16 @@ contract LocalNounsMinter is Ownable {
     require(token.totalSupply2() + _amount <= mintMax, 'Over the mint limit');
 
     uint256 mintPrice;
-    if(_prefectureId == 0){
+    if (_prefectureId == 0) {
       mintPrice = mintPriceForNotSpecified;
-    }else{
+    } else {
       mintPrice = mintPriceForSpecified;
     }
     require(msg.value >= mintPrice * _amount, 'Must send the mint price');
 
-    return token.mintSelectedPrefecture(msg.sender, _prefectureId, _amount);
+    tokenId = token.mintSelectedPrefecture(msg.sender, _prefectureId, _amount);
+
+    emit MintSelectedPrefecture(_prefectureId, _amount, msg.sender);
   }
 
   function withdraw() external payable onlyOwner {