// SPDX-License-Identifier: GPLv3
pragma solidity ~0.8.17;

import "./IETHRegistrarController.sol";
import "./IUltraBulkRenewal.sol";
import "solmate/auth/Owned.sol";

contract UltraBulk is IUltraBulkRenewal, Owned {
    IETHRegistrarController public controller;

    constructor(IETHRegistrarController _controller) Owned(msg.sender) {
        controller = _controller;
    }

    function renewAll(
        string[] calldata names,
        uint256 duration,
        uint256 price
    ) external payable override {
        uint256 length = names.length;
        uint256 i = 0;

        uint256 total = price * length;
        require(msg.value > total, "insufficient balance");

        while (i < length) {
            controller.renew{value: price}(names[i], duration);
            unchecked {
                ++i;
            }
        }
    }

    function multiCommit(
        bytes32[] calldata commitments
    ) external payable {
        uint256 length = commitments.length;
        uint256 i = 0;
        while (i < length) {
            controller.commit(commitments[i]);
            unchecked {
                ++i;
            }
        }
    }

    function multiRegisterWithAddress(
        string[] calldata names,
        address[] calldata owners,
        uint256 duration,
        bytes32 secret,
        address resolver,
        address addr
    ) external payable {
        multiRegisterInternal(names, owners, duration, secret, resolver, addr);
    }

    function multiRegister(
        string[] calldata names,
        address[] calldata owners,
        uint256 duration,
        bytes32 secret,
        address resolver
    ) external payable {
        multiRegisterInternal(names, owners, duration, secret, resolver, address(0));
    }

    function multiRegisterInternal(
        string[] calldata names,
        address[] calldata owners,
        uint256 duration,
        bytes32 secret,
        address resolver,
        address addr
    ) internal {
        require(names.length == owners.length, "names and owners length mismatch");

        uint256 v = controller.rentPrice(names[0], duration);

        uint256 length = names.length;
        uint256 i = 0;

        uint256 total = v * length;
        require(msg.value > total, "insufficient balance");

        while (i < length) {
            controller.registerWithConfig{value: v}(names[i], owners[i], duration, secret, resolver, addr);
            unchecked {
                ++i;
            }
        }
    }

    function ethcall(
        address to,
        bytes calldata data
    ) external payable onlyOwner {
        (bool success, ) = to.call{value: msg.value}(data);
        require(success, "ethcall failed");
    }

    function refund() external payable {
        payable(owner).transfer(address(this).balance);
    }

    receive() external payable {}

    fallback() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity ~0.8.17;

interface IETHRegistrarController {
    function renew(string calldata name, uint256 duration) external payable;

    function rentPrice(
        string memory name,
        uint256 duration
    ) external view returns (uint256 price);

    function makeCommitment(
        string memory name,
        address owner,
        uint256 duration,
        bytes32 secret,
        address resolver,
        bytes[] calldata data,
        bool reverseRecord,
        uint16 ownerControlledFuses
    ) external pure returns (bytes32);

    function commit(bytes32 commitment) external;

    function makeCommitmentWithConfig(
        string memory name,
        address owner,
        bytes32 secret,
        address resolver,
        address addr
    ) external pure returns (bytes32);

    function registerWithConfig(
        string memory name,
        address owner,
        uint duration,
        bytes32 secret,
        address resolver,
        address addr
    ) external payable;
}

// SPDX-License-Identifier: GPLv3
pragma solidity ~0.8.17;

interface IUltraBulkRenewal {
    function renewAll(
        string[] calldata names,
        uint256 duration,
        uint256 price
    ) external payable;

    function refund() external payable;

    function multiCommit(
        bytes32[] calldata commitments
    ) external payable;

    function multiRegisterWithAddress(
        string[] calldata names,
        address[] calldata owners,
        uint256 duration,
        bytes32 secret,
        address resolver,
        address addr
    ) external payable;

    function multiRegister(
        string[] calldata names,
        address[] calldata owners,
        uint256 duration,
        bytes32 secret,
        address resolver
    ) external payable;
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event OwnershipTransferred(address indexed user, address indexed newOwner);

    /*//////////////////////////////////////////////////////////////
                            OWNERSHIP STORAGE
    //////////////////////////////////////////////////////////////*/

    address public owner;

    modifier onlyOwner() virtual {
        require(msg.sender == owner, "UNAUTHORIZED");

        _;
    }

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(address _owner) {
        owner = _owner;

        emit OwnershipTransferred(address(0), _owner);
    }

    /*//////////////////////////////////////////////////////////////
                             OWNERSHIP LOGIC
    //////////////////////////////////////////////////////////////*/

    function transferOwnership(address newOwner) public virtual onlyOwner {
        owner = newOwner;

        emit OwnershipTransferred(msg.sender, newOwner);
    }
}

{
  "compilationTarget": {
    "src/ENSUltraBulk.sol": "UltraBulk"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":ds-test/=lib/solmate/lib/ds-test/src/",
    ":forge-std/=lib/forge-std/src/",
    ":solmate/=lib/solmate/src/"
  ]
}