ADD: aime contract

contracts/aime/AIMeFactory.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./AIMeNFT.sol";
+
+struct AIMeParams {
+    address creator;
+    string name;
+    string avatar;
+    string bio;
+    string image;
+    string socialKey;
+    string socialId;
+    uint256 minPrice;
+    uint256 priceIncrement;
+}
+
+interface IAIMeFactory {
+    function createAIMe(AIMeParams memory params) external returns (address);
+}
+
+/**
+ * AIMeFactory v1.0
+ * This contract is used for deploying new AIMeNFT contracts
+ */
+contract AIMeFactory is IAIMeFactory {
+
+    function createAIMe(
+        AIMeParams memory params
+    ) public returns (address) {
+        AIMeNFT aime = new AIMeNFT(
+            string(abi.encodePacked("EMIA:", params.name)),
+            params.name,
+            params.avatar,
+            params.bio,
+            params.image,
+            params.minPrice,
+            params.priceIncrement,
+            msg.sender
+        );
+        return address(aime);
+    }
+}

contracts/aime/AIMeManager.sol

@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import "./AIMeNFT.sol";
+import "./AIMePowerLauncher.sol";
+import "./AIMePowerChanger.sol";
+import "./AIMePowerChangeProposal.sol";
+import "./AIMeFactory.sol";
+
+contract AIMeManager is Ownable {
+    uint256 public protocolFee = 0.00001 ether;
+    address private _signer;
+
+    IAIMeFactory public aimeFactory;
+    IAIMePowerLauncher public aimePowerLauncher;
+    IAIMePowerChanger public aimePowerChanger;
+    address public aimePowerReward;
+
+    mapping(address => uint256) public addressNonce;
+    mapping(string => address) public aimeAddresses;
+    mapping(address => address) public aimeCreators;
+
+    mapping(address => address) public powerChangeProposals;
+
+    // events
+    event AIMeCreated(address creator, address aimeAddress);
+    event PowerChangeProposed(address proposal);
+
+    constructor() {}
+
+    function updateSigner(address signer) public onlyOwner {
+        _signer = signer;
+    }
+
+    function updateProtocolFee(uint256 _protocolFee) public onlyOwner {
+        protocolFee = _protocolFee;
+    }
+
+    function updateAIMeFactory(IAIMeFactory _aimeFactory) public onlyOwner {
+        aimeFactory = _aimeFactory;
+    }
+
+    function updateAIMePowerLauncher(
+        IAIMePowerLauncher _aimePowerLauncher
+    ) public onlyOwner {
+        aimePowerLauncher = _aimePowerLauncher;
+    }
+
+    function updateAIMePowerChanger(
+        IAIMePowerChanger _aimePowerChanger
+    ) public onlyOwner {
+        aimePowerChanger = _aimePowerChanger;
+    }
+
+    function updateAIMePowerReward(address _aimePowerReward) public onlyOwner {
+        aimePowerReward = _aimePowerReward;
+    }
+
+    function _createAIME(AIMeParams memory params) internal returns (address) {
+        require(msg.value >= protocolFee * 10, "Insufficient payment");
+        require(
+            aimeAddresses[params.name] == address(0),
+            "AIME already exists"
+        );
+        address aimeAddress = aimeFactory.createAIMe(params);
+
+        if (
+            bytes(params.socialKey).length != 0 &&
+            bytes(params.socialId).length != 0
+        ) {
+            IAIMeNFT(aimeAddress).mint(
+                aimeAddress,
+                params.socialKey,
+                "static",
+                params.socialId,
+                params.image,
+                0
+            );
+        }
+
+        aimeAddresses[params.name] = aimeAddress;
+
+        return aimeAddress;
+    }
+
+    function _checkSignature(
+        AIMeParams memory params,
+        address tokenAddress,
+        bytes memory signature
+    ) internal returns (bool) {
+        uint256 nonce = addressNonce[params.creator];
+        bytes32 _msgHash = ECDSA.toEthSignedMessageHash(
+            keccak256(
+                abi.encodePacked(
+                    params.creator,
+                    params.name,
+                    params.avatar,
+                    params.bio,
+                    params.image,
+                    abi.encodePacked(
+                        params.socialKey,
+                        params.socialId,
+                        params.minPrice,
+                        params.priceIncrement,
+                        tokenAddress,
+                        nonce
+                    )
+                )
+            )
+        );
+        require(
+            ECDSA.recover(_msgHash, signature) == _signer,
+            "Invalid signature"
+        );
+        addressNonce[params.creator] = nonce + 1;
+        return true;
+    }
+
+    function createAIME(AIMeParams memory params, bytes memory signature) public payable {
+        _checkSignature(params, address(0), signature);
+        address aimeAddress = _createAIME(params);
+        address power = aimePowerLauncher.launchPower(
+            params.name,
+            params.name,
+            aimePowerReward
+        );
+        IAIMeNFT(aimeAddress).setAIMePower(power);
+        aimeCreators[aimeAddress] = params.creator;
+
+        emit AIMeCreated(params.creator, aimeAddress);
+    }
+
+    function createAIMeWithToken(
+        AIMeParams memory params,
+        address tokenAddress,
+        bytes memory signature
+    ) public payable {
+        _checkSignature(params, tokenAddress, signature);
+        address aimeAddress = _createAIME(params);
+        IAIMeNFT(aimeAddress).setAIMePower(tokenAddress);
+        aimeCreators[aimeAddress] = params.creator;
+
+        emit AIMeCreated(params.creator, aimeAddress);
+    }
+
+    function mintAIMeNFT(
+        address aimeAddress,
+        string memory key,
+        string memory dataType,
+        string memory data,
+        string memory image,
+        uint256 amount,
+        bytes memory signature
+    ) public payable {
+        require(msg.value >= protocolFee, "Insufficient payment");
+        bytes32 _msgHash = ECDSA.toEthSignedMessageHash(
+            keccak256(
+                abi.encodePacked(
+                    msg.sender,
+                    aimeAddress,
+                    key,
+                    dataType,
+                    data,
+                    image,
+                    amount,
+                    addressNonce[msg.sender]
+                )
+            )
+        );
+        require(
+            ECDSA.recover(_msgHash, signature) == _signer,
+            "Invalid signature"
+        );
+        addressNonce[msg.sender] += 1;
+
+        IAIMeNFT aime = IAIMeNFT(aimeAddress);
+        aime.mint(msg.sender, key, dataType, data, image, amount);
+    }
+
+    function updateAIMeNFT(
+        address aimeAddress,
+        uint256 tokenId,
+        string memory data,
+        string memory image,
+        bytes memory signature
+    ) public payable {
+        require(msg.value >= protocolFee, "Insufficient payment");
+        bytes32 _msgHash = ECDSA.toEthSignedMessageHash(
+            keccak256(
+                abi.encodePacked(
+                    msg.sender,
+                    aimeAddress,
+                    tokenId,
+                    data,
+                    image,
+                    addressNonce[msg.sender]
+                )
+            )
+        );
+        require(
+            ECDSA.recover(_msgHash, signature) == _signer,
+            "Invalid signature"
+        );
+        addressNonce[msg.sender] += 1;
+
+        IAIMeNFT aime = IAIMeNFT(aimeAddress);
+        aime.updateAIMeInfo(tokenId, msg.sender, data, image);
+    }
+
+    function proposePowerChange(address aimeAddress, address to) public {
+        require(aimeCreators[aimeAddress] != address(0), "Invalid AIME");
+        address proposal = aimePowerChanger.createProposal(aimeAddress, to);
+        powerChangeProposals[proposal] = msg.sender;
+        emit PowerChangeProposed(proposal);
+    }
+
+    function executePowerChange() public {
+        require(powerChangeProposals[msg.sender] != address(0), "Invalid proposal");
+        IAIMePowerChangeProposal proposal = IAIMePowerChangeProposal(
+            msg.sender
+        );
+        IAIMeNFT(proposal.getAIME()).setAIMePower(proposal.getTo());
+    }
+
+    receive() external payable {}
+
+    function withdrawFee() public onlyOwner {
+        uint256 amount = address(this).balance;
+        (bool success, ) = owner().call{value: amount}("");
+        require(success, "Failed to send Ether");
+    }
+}