@ApiTags('auth')
@Controller('api/auth')
export class AuthController {
  /**
   * 지갑 로그인 요청
   * */
  @Post('web3-request')
  @ApiResponseEntity({
    type: AuthCramOutDto,
    summary: '회원가입 및 로그인',
  })
  async web3Request(
    @Body() web3RequestInDto: Web3RequestInDto,
  ): Promise<ResponseEntity<AuthCramOutDto>> {
    const challenge = this.authService.signChallenge(web3RequestInDto.address);

    return ResponseEntity.ok().body(
      AuthCramOutDto.of().setChallenge(challenge),
    );
  }

  /**
   * 지갑 로그인 검증
   * */
  @Post('web3-verify')
  @ApiResponseEntity({
    type: AuthSignUserOutDto,
    summary: 'wallet 로그인',
  })
  async web3Verify(
    @Body() web3VerifyInDto: Web3VerifyInDto,
  ): Promise<ResponseEntity<AuthSignUserOutDto>> {
    const { challenge, address, signature } = web3VerifyInDto;

    // 1. challenge 확인
    this.authService.verifyChallenge(address, challenge);
    // 2. wallet 서명 확인
    await this.web3Service.web3Service.verifySignature(
      address,
      signature,
      challenge,
    );

    // 3.계정 생성 및 로그인
    const authSignUserOutDto = await this.authService.web3Register(address);

    return ResponseEntity.ok().body(authSignUserOutDto);
  }

pragma solidity ^0.8.19;

import "../../utils/PortfolioSuperOperatorsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract AdminAirdropCoin is Initializable, ReentrancyGuardUpgradeable, PortfolioSuperOperatorsUpgradeable, UUPSUpgradeable {
    event AirdropCoin(address indexed receiver, uint256 amount);
    event Withdraw(address indexed to, uint256 amount);
    event Deposit(address indexed from, uint256 amount);

    constructor() {
        _disableInitializers();
    }

    /// @notice 컨트랙트 초기화
    /// @param operator 오퍼레이터 이름
    /// @param portfolioAdmin 관리자 주소
    function initialize(string memory operator, address portfolioAdmin) public initializer {
        __ReentrancyGuard_init();
        __UUPSUpgradeable_init();
        __PortfolioSuperOperators_init(operator, portfolioAdmin);
    }

    /// @notice 에어드랍 정보 구조체
    struct AirdropInfo {
        address receiver;
        uint256 amount; // ETH 단위 (Wei로 자동 변환됨)
    }

    /// @notice 다중 에어드랍 실행
    /// @param airdropInfos 에어드랍 정보 배열
    function airdrop(AirdropInfo[] memory airdropInfos) external onlySuperOperator nonReentrant {
        uint256 length = airdropInfos.length;
        require(length > 0, "Empty array");
        require(length <= 500, "Too many recipients");

        uint256 totalAmount = 0;

        // 1단계: 유효성 검증 및 총액 계산
        for (uint256 i = 0; i < length; ) {
            require(airdropInfos[i].receiver != address(0), "Invalid address");
            require(airdropInfos[i].amount > 0, "Invalid amount");

            uint256 amountInWei = airdropInfos[i].amount * 10 ** 18;
            totalAmount += amountInWei;

            unchecked { ++i; }
        }

        require(address(this).balance >= totalAmount, "Insufficient balance");

        // 2단계: 전송 실행
        for (uint256 i = 0; i < length; ) {
            address payable recipient = payable(airdropInfos[i].receiver);
            uint256 amountInWei = airdropInfos[i].amount * 10 ** 18;

            (bool success, ) = recipient.call{value: amountInWei}("");
            require(success, "Transfer failed");

            emit AirdropCoin(recipient, amountInWei);

            unchecked { ++i; }
        }
    }

    /// @notice 컨트랙트에 코인 충전
    function charging() external payable onlySuperOperator {
        require(msg.value > 0, "Invalid amount");
        emit Deposit(msg.sender, msg.value);
    }

    /// @notice 컨트랙트 잔액 전액 출금
    function withdraw() external onlySuperOperator nonReentrant {
        uint256 balance = address(this).balance;
        require(balance > 0, "No balance");

        (bool success, ) = msg.sender.call{value: balance}("");
        require(success, "Transfer failed");

        emit Withdraw(msg.sender, balance);
    }

    /// @notice 특정 금액만 출금
    /// @param amount 출금할 금액 (Wei)
    function withdrawAmount(uint256 amount) external onlySuperOperator nonReentrant {
        require(amount > 0, "Invalid amount");
        require(address(this).balance >= amount, "Insufficient balance");

        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");

        emit Withdraw(msg.sender, amount);
    }

    /// @notice 현재 컨트랙트 잔액 조회
    /// @return 잔액 (Wei)
    function getBalance() external view returns (uint256) {
        return address(this).balance;
    }

    /// @notice 일반 전송 수신
    receive() external payable {
        emit Deposit(msg.sender, msg.value);
    }

    /// @dev UUPS 업그레이드 권한 검증
    function _authorizeUpgrade(address newImplementation) internal override onlySuperOperator {}

    /// @dev 스토리지 갭
    uint256[30] private __AdminAirdropCoinGap;
}

pragma solidity ^0.8.19;

import "../../utils/PortfolioSuperOperatorsUpgradeable.sol";
import "./Erc1155ClaimStruct.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

contract Erc1155ClaimProof is Initializable, PortfolioSuperOperatorsUpgradeable, UUPSUpgradeable {
    event SetRoot(uint256 indexed round, bytes32 indexed root);
    event ClaimProof(address indexed userAddress, uint256 indexed id, uint256 indexed tokenId, ProofInfo proofInfo);

    // round => root
    mapping(uint256 => bytes32) public rootList;
    mapping(address => mapping(uint256 => bool)) public useClaimStatus;

    constructor() {
        _disableInitializers();
    }

    function initialize(string memory operator, address portfolioAdmin) public initializer {
        __UUPSUpgradeable_init();
        __PortfolioSuperOperators_init(operator, portfolioAdmin);
    }

    function _authorizeUpgrade(address newImplementation) internal override onlySuperOperator {}

    function getRoot(uint256 _round) public view returns (bytes32) {
        return rootList[_round];
    }

    function setRoot(SetRootInfo memory _setRootInfo) external onlySuperOperator {
        rootList[_setRootInfo.round] = _setRootInfo.root;
        emit SetRoot(_setRootInfo.round, _setRootInfo.root);
    }

    function setRootList(SetRootInfo[] memory _setRootInfos) external onlySuperOperator {
        for (uint8 i = 0; i < _setRootInfos.length;) {
            rootList[_setRootInfos[i].round] = _setRootInfos[i].root;
            emit SetRoot(_setRootInfos[i].round, _setRootInfos[i].root);
            unchecked { ++i; }
        }
    }

    function claimProof(ProofInfo memory _proofInfo) external onlySuperOperator {
        require(verifyClaim(_proofInfo), "invalid proof");
        require(!useClaimStatus[_proofInfo.userAddress][_proofInfo.id], "round : already claimed");

        useClaimStatus[_proofInfo.userAddress][_proofInfo.id] = true;
        emit ClaimProof(_proofInfo.userAddress, _proofInfo.id, _proofInfo.tokenId, _proofInfo);
    }

    function verifyClaim(
        ProofInfo memory _proofInfo
    ) private view returns (bool) {
        bytes32 leaf = keccak256(abi.encodePacked(_proofInfo.id, _proofInfo.userAddress, _proofInfo.claimType, _proofInfo.tokenId, _proofInfo.amount));
        return verifyProof(_proofInfo.proof, rootList[_proofInfo.round], leaf);
    }


    function verifyProof(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    function processProof(bytes32[] memory proof, bytes32 leaf)
    internal
    pure
    returns (bytes32)
    {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                computedHash = keccak256(
                    abi.encodePacked(computedHash, proofElement)
                );
            } else {
                computedHash = keccak256(
                    abi.encodePacked(proofElement, computedHash)
                );
            }
        }
        return computedHash;
    }

    uint256[30] private __Erc1155ClaimProofGap;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract GachaMachine is ERC1155, Ownable, ReentrancyGuard {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    // 가챠 토큰 ID (소각용)
    uint256 public constant GACHA_TOKEN_ID = 3000; // 도형 가챠팩
    uint256 public constant NUMBER_GACHA_TOKEN_ID = 3001; // 숫자 가챠팩

    // NFT 토큰 ID 범위
    uint256 public constant SHAPE_TOKEN_START = 1000;
    uint256 public constant NUMBER_TOKEN_START = 2001;

    // 가챠 결과 이벤트
    event GachaResult(
        address indexed player,
        uint256 indexed gachaType, // 0: Shape, 1: Number
        uint256 indexed tokenId,
        uint256 tier // 0: N, 1: R, 2: SR, 3: SSR
    );

    // 티어 확률 (basis points: 10000 = 100%)
    struct TierProbability {
        uint256 N;   // 50%
        uint256 R;   // 30%
        uint256 SR;  // 15%
        uint256 SSR; // 5%
    }

    TierProbability public tierProbability = TierProbability(5000, 3000, 1500, 500);

    // 가챠 타입별 최대 토큰 수
    mapping(uint256 => uint256) public maxTokenCount;
    
    // 이미 민팅된 토큰 ID 추적
    mapping(uint256 => bool) public isTokenMinted;

    constructor(string memory uri) ERC1155(uri) {
        maxTokenCount[0] = 1000; // Shape 가챠 최대 1000개
        maxTokenCount[1] = 1000; // Number 가챠 최대 1000개
    }

    /**
     * @dev 가챠 실행 함수
     * @param gachaType 0: Shape 가챠, 1: Number 가챠
     * @param seed 랜덤 시드 (프론트엔드에서 생성)
     */
    function executeGacha(uint256 gachaType, uint256 seed) 
        external 
        nonReentrant 
    {
        require(gachaType == 0 || gachaType == 1, "Invalid gacha type");
        
        // 가챠 토큰 소각
        uint256 gachaTokenId = gachaType == 0 ? GACHA_TOKEN_ID : NUMBER_GACHA_TOKEN_ID;
        require(balanceOf(msg.sender, gachaTokenId) > 0, "No gacha token");
        
        // 가챠 토큰 1개 소각
        _burn(msg.sender, gachaTokenId, 1);

        // 티어 결정
        uint256 tier = _determineTier(seed);
        
        // 토큰 ID 생성
        uint256 tokenId = _generateTokenId(gachaType, tier);
        
        // NFT 민팅
        _mint(msg.sender, tokenId, 1, "");

        // 이벤트 발생
        emit GachaResult(msg.sender, gachaType, tokenId, tier);
    }

    /**
     * @dev 티어 결정 함수
     * @param seed 랜덤 시드
     * @return tier 결정된 티어 (0: N, 1: R, 2: SR, 3: SSR)
     */
    function _determineTier(uint256 seed) internal view returns (uint256) {
        uint256 random = uint256(keccak256(abi.encodePacked(seed, block.timestamp, msg.sender))) % 10000;
        
        uint256 cumulative = 0;
        
        // SSR (5%)
        cumulative += tierProbability.SSR;
        if (random < cumulative) return 3;
        
        // SR (15%)
        cumulative += tierProbability.SR;
        if (random < cumulative) return 2;
        
        // R (30%)
        cumulative += tierProbability.R;
        if (random < cumulative) return 1;
        
        // N (50%)
        return 0;
    }

    /**
     * @dev 토큰 ID 생성 함수
     * @param gachaType 가챠 타입
     * @param tier 티어
     * @return tokenId 생성된 토큰 ID
     */
    function _generateTokenId(uint256 gachaType, uint256 tier) internal returns (uint256) {
        uint256 startId = gachaType == 0 ? SHAPE_TOKEN_START : NUMBER_TOKEN_START;
        uint256 tokenId;
        
        // 티어별 범위 내에서 랜덤 토큰 ID 생성
        uint256 tierStart = startId + (tier * 250); // 각 티어당 250개씩
        uint256 tierEnd = tierStart + 249;
        
        // 이미 민팅된 토큰이 아닐 때까지 반복
        do {
            tokenId = tierStart + (uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, _tokenIds.current()))) % 250);
        } while (isTokenMinted[tokenId] && tokenId <= tierEnd);
        
        require(tokenId <= tierEnd, "No available tokens in this tier");
        
        isTokenMinted[tokenId] = true;
        _tokenIds.increment();
        
        return tokenId;
    }

    /**
     * @dev 티어 확률 업데이트 (관리자만)
     */
    function updateTierProbability(
        uint256 _N,
        uint256 _R, 
        uint256 _SR,
        uint256 _SSR
    ) external onlyOwner {
        require(_N + _R + _SR + _SSR == 10000, "Total probability must be 100%");
        tierProbability = TierProbability(_N, _R, _SR, _SSR);
    }

    /**
     * @dev 가챠 토큰 배치 민팅 (관리자만)
     */
    function batchMintGachaTokens(
        address[] calldata to,
        uint256[] calldata amounts,
        uint256 gachaType
    ) external onlyOwner {
        require(to.length == amounts.length, "Arrays length mismatch");
        
        uint256 gachaTokenId = gachaType == 0 ? GACHA_TOKEN_ID : NUMBER_GACHA_TOKEN_ID;
        
        for (uint256 i = 0; i < to.length; i++) {
            _mint(to[i], gachaTokenId, amounts[i], "");
        }
    }

    /**
     * @dev 토큰 URI 설정
     */
    function setURI(string memory newuri) public onlyOwner {
        _setURI(newuri);
    }
}