// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/utils/introspection/IERC165.sol";

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

import "@openzeppelin/contracts/interfaces/IERC1271.sol";

import "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";

import "./interfaces/IERC6551Account.sol";

import "./interfaces/IERC6551Executable.sol";

contract ERC6551Account is

    IERC165,

    IERC1271,

    IERC6551Account,

    IERC6551Executable

{

    uint256 public state;

    receive() external payable {}

    function execute(

        address to,

        uint256 value,

        bytes calldata data,

        uint256 operation

    ) public payable virtual returns (bytes memory result) {

        require(_isValidSigner(msg.sender), "Invalid signer");

        require(operation == 0, "Only call operations are supported");

        ++state;

        bool success;

        (success, result) = to.call{value: value}(data);

        if (!success) {

            assembly {

                revert(add(result, 32), mload(result))

            }

        }

    }

    function isValidSigner(

        address signer,

        bytes calldata

    ) public view virtual returns (bytes4) {

        if (_isValidSigner(signer)) {

            return IERC6551Account.isValidSigner.selector;

        }

        return bytes4(0);

    }

    function isValidSignature(

        bytes32 hash,

        bytes memory signature

    ) public view virtual returns (bytes4 magicValue) {

        bool isValid = SignatureChecker.isValidSignatureNow(

            owner(),

            hash,

            signature

        );

        if (isValid) {

            return IERC1271.isValidSignature.selector;

        }

        return "";

    }

    function supportsInterface(

        bytes4 interfaceId

    ) public pure virtual returns (bool) {

        return (interfaceId == type(IERC165).interfaceId ||

            interfaceId == type(IERC6551Account).interfaceId ||

            interfaceId == type(IERC6551Executable).interfaceId);

    }

    function token() public view virtual returns (uint256, address, uint256) {

        bytes memory footer = new bytes(0x60);

        assembly {

            extcodecopy(address(), add(footer, 0x20), 0x4d, 0x60)

        }

        return abi.decode(footer, (uint256, address, uint256));

    }

    function owner() public view virtual returns (address) {

        (uint256 chainId, address tokenContract, uint256 tokenId) = token();

        if (chainId != block.chainid) return address(0);

        return IERC721(tokenContract).ownerOf(tokenId);

    }

    function _isValidSigner(

        address signer

    ) internal view virtual returns (bool) {

        return signer == owner();

    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/utils/Create2.sol";

import "./interfaces/IERC6551Registry.sol";

import "./lib/ERC6551BytecodeLib.sol";

contract ERC6551Registry is IERC6551Registry {

    error AccountCreationFailed();

    function createAccount(

        address implementation,

        uint256 chainId,

        address tokenContract,

        uint256 tokenId,

        uint256 salt,

        bytes calldata initData

    ) external returns (address) {

        bytes memory code = ERC6551BytecodeLib.getCreationCode(

            implementation,

            chainId,

            tokenContract,

            tokenId,

            salt

        );

        address _account = Create2.computeAddress(

            bytes32(salt),

            keccak256(code)

        );

        if (_account.code.length != 0) return _account;

        emit AccountCreated(

            _account,

            implementation,

            chainId,

            tokenContract,

            tokenId,

            salt

        );

        assembly {

            _account := create2(0, add(code, 0x20), mload(code), salt)

        }

        if (_account == address(0)) revert AccountCreationFailed();

        if (initData.length != 0) {

            (bool success, bytes memory result) = _account.call(initData);

            if (!success) {

                assembly {

                    revert(add(result, 32), mload(result))

                }

            }

        }

        return _account;

    }

    function account(

        address implementation,

        uint256 chainId,

        address tokenContract,

        uint256 tokenId,

        uint256 salt

    ) external view returns (address) {

        bytes32 bytecodeHash = keccak256(

            ERC6551BytecodeLib.getCreationCode(

                implementation,

                chainId,

                tokenContract,

                tokenId,

                salt

            )

        );

        return Create2.computeAddress(bytes32(salt), bytecodeHash);

    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import "./CosmicCowboy.sol";

import "./SpaceGrub.sol";

import "./RocketFuel.sol";

import "./GoldenCorn.sol";

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/utils/Create2.sol";

import "./ERC6551BytecodeLib.sol";

library ERC6551AccountLib {

    function computeAddress(

        address registry,

        address implementation,

        uint256 chainId,

        address tokenContract,

        uint256 tokenId,

        uint256 _salt

    ) internal pure returns (address) {

        bytes32 bytecodeHash = keccak256(

            ERC6551BytecodeLib.getCreationCode(

                implementation,

                chainId,

                tokenContract,

                tokenId,

                _salt

            )

        );

        return Create2.computeAddress(bytes32(_salt), bytecodeHash, registry);

    }

    function token() internal view returns (uint256, address, uint256) {

        bytes memory footer = new bytes(0x60);

        assembly {

            // copy 0x60 bytes from end of footer

            extcodecopy(address(), add(footer, 0x20), 0x4d, 0x60)

        }

        return abi.decode(footer, (uint256, address, uint256));

    }

    function salt() internal view returns (uint256) {

        bytes memory footer = new bytes(0x20);

        assembly {

            // copy 0x20 bytes from beginning of footer

            extcodecopy(address(), add(footer, 0x20), 0x2d, 0x20)

        }

        return abi.decode(footer, (uint256));

    }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

library ERC6551BytecodeLib {

    function getCreationCode(

        address implementation_,

        uint256 chainId_,

        address tokenContract_,

        uint256 tokenId_,

        uint256 salt_

    ) internal pure returns (bytes memory) {

        return

            abi.encodePacked(

                hex"3d60ad80600a3d3981f3363d3d373d3d3d363d73",

                implementation_,

                hex"5af43d82803e903d91602b57fd5bf3",

                abi.encode(salt_, chainId_, tokenContract_, tokenId_)

            );

    }

}

        "@openzeppelin/contracts": "^5.0.0",

        "ethers": "^6.7.1"

      "integrity": "sha512-0h+FrQDqe2Wn+IIGFkTCd4aAwTJ+7834Ek1COohCyV26AXhwQ7WQaz+4F/nLOeVl/3BtWHOHLPsq46V8YB46Eg=="

      ]

      "integrity": "sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q=="

      "integrity": "sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q=="

      "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ=="

    "@openzeppelin/contracts": "^5.0.0",

    "ethers": "^6.7.1"

async function CosmicCoyboys() {

async function GoldenCorn() {

  let contract;

  let owner;

  let addr1;

  let addr2;

  // Get the signers from ethers

  [owner, addr1, addr2] = await ethers.getSigners();

  // Deploy the contract

  const Contract = await ethers.getContractFactory("GoldenCorn");

  contract = await Contract.deploy(owner.address);

  const contractAddress = await contract.getAddress()

  console.log("Contract deployed to address:", contractAddress);

  // Mint tokens

  await contract.mint(addr1.address, 100);

  console.log("Minted token 1");

  const balance = await contract.balanceOf(addr1.address);

  console.log(balance)

}

async function TBA() {

  let contract;

  let owner;

  let addr1;

  let addr2;

  // Get the signers from ethers

  [owner, addr1, addr2] = await ethers.getSigners();

  // Deploy the contract

  const RegistryContract = await ethers.getContractFactory("ERC6551Registry");

  const regristryContract = await RegistryContract.deploy();

  const registryContractAddress = await regristryContract.getAddress()

  console.log("Registry Contract deployed to address:", registryContractAddress);

  const AccountContract = await ethers.getContractFactory("ERC6551Account");

  const accountContract = await AccountContract.deploy();

  const accountContractAddress = await accountContract.getAddress()

  console.log("Account Contract deployed to address:", accountContractAddress);

}

TBA()