Surge Women Passport
SURGE
ipfs://QmYVsw73haPgm9jK9BopsuKtzuxLANjYn75xeHLpht13D5/1802

function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
    if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

    // baseURI是目录的URI
    string memory baseURI = _baseURI();
    // 将目录的URI和tokenId拼接在一起就是token的URI
    return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : '';
}

constructor(
    string memory _name,
    string memory _symbol,
    string memory _baseTokenURI,
    uint128 _price,
    address _receiver,
    uint256 _royalties
) payable ERC721A(_name, _symbol) {
    setBaseURI(_baseTokenURI);
    setPrice(_price);
    setRoyalties(_receiver, _royalties);
}

/// @notice Presale minting verifies callers address is in Merkle Root
/// @param _amountOfTokens Amount of tokens to mint
/// @param _merkleProof Hash of the callers address used to verify the location of that address in the Merkle Root
function presaleMint(uint256 _amountOfTokens, bytes32[] calldata _merkleProof)
    external
    payable
    verifyMaxPerUser(msg.sender, _amountOfTokens)
    verifyMaxSupply(_amountOfTokens)
    isEnoughEth(_amountOfTokens)
{
    require(status == SaleStatus.Presale, "Presale not active");

    bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
    require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Not in presale list");

    _mintedAmount[msg.sender] += _amountOfTokens;
    _safeMint(msg.sender, _amountOfTokens);
}

/// @notice Set Presale Merkle Root
/// @param _merkleRoot Merkle Root hash
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
    merkleRoot = _merkleRoot;
}

    /理想人生价值\   自我实现需求
   / 尊重需求     \  （自尊、他尊）
  /  社交需求      \  （归属和爱的需求）
 /   安全需求       \  （人身、健康、职业安全等）
/    生理需求        \  （食物、水、睡眠）

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IERC721 /* is ERC165 */ {
    // 事件：转移token
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    //事件： 授权approved管理owner的tokenId
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    //事件：  授权operator管理所有资产
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    // 获取token的数量
    function balanceOf(address owner) external view returns (uint256 balance);

    // 获取token所有者
    function ownerOf(uint256 tokenId) external view returns (address owner);

    // 安全转移，首先会检查合约是否能够识别ERC721协议，以防止转进区的NFT被锁住
    // from, to 都不能是零地址
    // 如果调用者不是from，那么，在此之前必须已经被授权
    // 如果to是智能合约，那么，to必须实现IERC721Receiver-onERC721Received
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    
    // 转移函数
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

   
    // 授权函数
    function approve(address to, uint256 tokenId) external;

    
    // 获取某个token授权的账户
    function getApproved(uint256 tokenId) external view returns (address operator);

   
    // 授权operator管理所有资产 
    function setApprovalForAll(address operator, bool _approved) external;

   
    // 检查是否有授权
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    
    // 同上，多了一个data参数
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

interface ERC165 {
    /// @notice Query if a contract implements an interface
    /// @param interfaceID The interface identifier, as specified in ERC-165
    /// @dev Interface identification is specified in ERC-165. This function
    ///  uses less than 30,000 gas.
    /// @return `true` if the contract implements `interfaceID` and
    ///  `interfaceID` is not 0xffffffff, `false` otherwise
    function supportsInterface(bytes4 interfaceID) external view returns (bool);
}


//用于接收ERC721的智能合约必须实现此 `IERC721Receiver` 接口
/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    // 当智能合约收到ERC721 token时，此函数就会被调用，并返回一个selector以确认收到了token    
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

Kitty[] kitties; 

uint256 newKittenId = kitties.push(_kitty) - 1; // push 会返回数组的长度，用元素的index作为token的ID