Zhuang's Diary

pragma solidity ^0.6.12;

contract AutoShop {
    address[] autoAssets;
    function createChildContract(string memory brand, string memory model) public payable {
        // 增加检查：ether是否足够支付 car
        address newAutoAsset = address(new AutoAsset(brand, model, msg.sender));
        autoAssets.push(newAutoAsset);
    }
    function getDeployChildContracts() public view returns (address[] memory) {
        return autoAssets;
    }
}

contract AutoAsset {
    string brand;
    string model;
    address owner;
    constructor(string memory _brand, string memory _model, address _owner) public {
        brand = _brand;
        model = _model;
        owner = _owner;
    }
}

pragma solidity ^0.6.12;

contract NameRegistry {
    struct ContractDetails {
        address owner;
        address contractAddress;
        uint16 version;
    }
    mapping(string => ContractDetails) registry;
    
    function registerName(string memory name, address addr, uint16 ver) public returns (bool) {
        // 版本号码从1开始
        require(ver >= 1);
        ContractDetails memory info = registry[name];
        require(info.owner == msg.sender);
        // 如果在当前的registry不存在的话，创建记录
        if(info.contractAddress == address(0)) {
            info = ContractDetails({
                owner:msg.sender,
                contractAddress:addr,
                version:ver
            });
        } else {
            info.version = ver;
            info.contractAddress = addr;
        }
        // 修改 registry 里的记录
        registry[name] = info;
        return true;
    }
    
    function getContractDetails(string memory name) public view returns (address, uint16) {
        return(registry[name].contractAddress, registry[name].version);
    }
}

pragma solidity ^0.6.12;

contract SelfDesctructionContract {
    address payable owner;
    
    modifier ownerRestricted {
        require (owner == msg.sender);
        _;
    }
    
    // 构造函数
    constructor() public {
        owner = msg.sender;
    }

    // 使用ownerRestricted修饰符来限定只有合约的所有者才能调用该函数
    function destructContract() public payable ownerRestricted {
        selfdestruct(owner);
    }
}

// contracts/GameItem.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract GameItem is ERC721 {
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor() public ERC721("GameItem", "ITM") {}

    function awardItem(address player, string memory tokenURI)
        public
        returns (uint256)
    {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(player, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }
}