becrypto/contracts/logic/UserMinterFactory.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import "../interfaces/IBEERC721.sol";
import "../interfaces/IBEERC1155.sol";
import "./FactoryBase.sol";
import "./MinterFactory.sol";

contract UserMinterFactory is Ownable, FactoryBase, Initializable {
  MinterFactory factory;
  IBEERC721 public hero;
  IBEERC721 public equip;
  IBEERC1155 public chip;
  IBEERC1155 public shard;

  event TokenMintFail(
    address indexed to,
    bytes signature,
    string reason,
    bytes byteReason
  );

  function init(address[5] calldata addressArr) external initializer onlyOwner {
    hero = IBEERC721(addressArr[0]);
    equip = IBEERC721(addressArr[1]);
    chip = IBEERC1155(addressArr[2]);
    shard = IBEERC1155(addressArr[3]);
    factory = MinterFactory(addressArr[4]);
  }
  /**
   * @dev mint hero by user
   */
  function mintHeroUser(
    uint256 tokenId,
    uint256 startTime,
    uint256 saltNonce,
    bytes calldata signature
  ) external returns (bool success){
    address to = _msgSender();
    try factory.mint721ByUser(to, tokenId, startTime, saltNonce, signature, hero) {
      return true;
    } catch Error(string memory reason) {
      bytes memory by;
      factory.useSignature(signature);
      emit TokenMintFail(
        to,
        signature,
        reason,
        by
      );
      return false;
    } catch (bytes memory lowLevelData) {
      factory.useSignature(signature);
      string memory reason;
      emit TokenMintFail(
        to,
        signature,
        reason,
        lowLevelData
      );
      return false;
    }

  }

  /**
   * @dev user mint equip
   */
  function mintEquipUser(
    uint256 tokenId,
    uint256 startTime,
    uint256 saltNonce,
    bytes calldata signature
  ) external returns (bool success){
    address to = _msgSender();
    try factory.mint721ByUser(to, tokenId, startTime, saltNonce, signature, equip) {
      return true;
    } catch Error(string memory reason) {
      bytes memory by;
      factory.useSignature(signature);
      emit TokenMintFail(
        to,
        signature,
        reason,
        by
      );
      return false;
    } catch (bytes memory lowLevelData) {
      factory.useSignature(signature);
      string memory reason;
      emit TokenMintFail(
        to,
        signature,
        reason,
        lowLevelData
      );
      return false;
    }

  }

  /**
  * @dev user batch mint 1155 chip
  */
  function mintChipBatchUser(
    uint256[] memory ids,
    uint256 startTime,
    uint256 saltNonce,
    bytes calldata signature
  ) external returns (bool success){
    uint256 len = ids.length;
    uint256[] memory amounts = new uint256[](len);
    for (uint256 i = 0; i < len; ++i) {
      amounts[i] = 1;
    }
    address to = _msgSender();
    try factory.mint1155BatchByUser(to, ids, amounts, startTime, saltNonce, signature, chip) {
      return true;
    } catch Error(string memory reason) { 
      bytes memory by;
      factory.useSignature(signature);
      emit TokenMintFail(
        to,
        signature,
        reason,
        by
      );
      return false;
    } catch (bytes memory lowLevelData) {
      factory.useSignature(signature);
      string memory reason;
      emit TokenMintFail(
        to,
        signature,
        reason,
        lowLevelData
      );
      return false;
    }
  }

  /**
  * @dev user batch mint 1155 shard
  */
  function mintShardBatchUser(
    uint256[] memory ids,
    uint256[] memory amounts,
    uint256 startTime,
    uint256 saltNonce,
    bytes calldata signature
  ) external returns (bool success){
    address to = _msgSender();
    try factory.mint1155BatchByUser(to, ids, amounts, startTime, saltNonce, signature, shard) {
      return true;
    } catch Error(string memory reason) {
      bytes memory by;
      factory.useSignature(signature);
      emit TokenMintFail(
        to,
        signature,
        reason,
        by
      );
      return false;
    } catch (bytes memory lowLevelData) {
      factory.useSignature(signature);
      string memory reason;
      emit TokenMintFail(
        to,
        signature,
        reason,
        lowLevelData
      );
      return false;
    }
  }
  /**
    * @dev mint hero or equip with shard
    */
  function shardMixByUser(
    uint256 nftId,
    uint8 nftType,
    address payToken,
    uint256 tokenAmount,
    uint256[] memory ids,
    uint256[] memory amounts,
    uint256 startTime,
    uint256 saltNonce,
    bytes calldata signature
  ) external returns (bool success) {
    address to = _msgSender();
    IBEERC721 nft;
    if (nftType == 0) {
      nft = hero;
    } else {
      nft = equip;
    }
    ShardParam memory param = ShardParam(
      to, nftId, payToken, tokenAmount, startTime, saltNonce);
    try factory.shardMixByUser(
      param,
      ids, 
      amounts, 
      signature, 
      nft
    ) {
      return true;
    } catch Error(string memory reason) {
      bytes memory by;
      factory.useSignature(signature);
      emit TokenMintFail(
        to,
        signature,
        reason,
        by
      );
      return false;
    } catch (bytes memory lowLevelData) {
      factory.useSignature(signature);
      string memory reason;
      emit TokenMintFail(
        to,
        signature,
        reason,
        lowLevelData
      );
    }

  } 

}