// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "minter.sol";
contract BridgeMinter{
    address private notary;
    address private approver;
    address private tokenAddress;
    bool private bridging;
    uint256 private chainId;
    bytes32 private domainSeparator;
    mapping(bytes32 => bool) private nonces;
    event Bridged(address receiver, uint256 amount);
    event TransferOwnership(address indexed owner, bool indexed confirmed);
    constructor(address _approver, address _notary, address _tokenAddress, uint256 _chainId){
        require(_approver != address(0));     // dev: invalid approver
        require(_notary != address(0));       // dev: invalid notary
        require(_tokenAddress != address(0)); // dev: invalid notary
        approver = _approver;
        notary = _notary;
        tokenAddress = _tokenAddress;
        chainId = _chainId;
        domainSeparator = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId)"),
                keccak256("Neptune Bridge"), 
                keccak256("0.0.1"), 
                _chainId
            )
        );
    }
    modifier checkNonce(bytes32 nonce) {
        require(nonces[nonce]==false); // dev: already processed
        _;
    }
    function bridge(address sender, uint256 bridgedAmount, bytes32 nonce, bytes32 messageHash, bytes calldata approvedMessage, bytes calldata notarizedMessage) 
    external checkNonce(nonce){
        require(bridging == false);                                                //dev: re-entrancy guard
        bridging = true;
        bytes32 hashToVerify = keccak256(
            abi.encode(keccak256("SignedMessage(bytes32 key,address sender,uint256 amount)"),nonce,sender,bridgedAmount)
        );
        require(checkEncoding(approvedMessage,messageHash,hashToVerify,approver)); //dev: invalid signature
        require(checkEncoding(notarizedMessage,messageHash,hashToVerify,notary));  //dev: invalid signature
        nonces[nonce]=true;
        IMinter(tokenAddress).mint(sender, bridgedAmount);
        emit Bridged(sender, bridgedAmount);
        bridging = false;
    }
    function checkEncoding(bytes memory signedMessage,bytes32 messageHash, bytes32 hashToVerify, address signer) 
    internal view returns(bool){
        bytes32 domainSeparatorHash = keccak256(abi.encodePacked("\\x19\\x01", domainSeparator, hashToVerify));
        require(messageHash == domainSeparatorHash); //dev: values do not match
        return signer == recoverSigner(messageHash, signedMessage);
    }
    function splitSignature(bytes memory sig)
    internal pure returns (uint8 v, bytes32 r, bytes32 s){
        require(sig.length == 65); // dev: signature invalid
        assembly {
            // first 32 bytes, after the length prefix.
            r := mload(add(sig, 32))
            // second 32 bytes.
            s := mload(add(sig, 64))
            // final byte (first byte of the next 32 bytes).
            v := byte(0, mload(add(sig, 96)))
        }
        return (v, r, s);
    }
    function recoverSigner(bytes32 message, bytes memory sig)
    internal pure returns (address){
        uint8 v;
        bytes32 r;
        bytes32 s;
        (v, r, s) = splitSignature(sig);
        return tryRecover(message, v, r, s);
    }
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s)
    internal 
    pure 
    returns (address) {
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return address(0);
        } else if (v != 27 && v != 28) {
            return address(0);
        }
        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return address(0);
        }
        return signer;
    }
}// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.10;
/**
 * @dev Interface of to mint ERC20 tokens.
 */
interface IMinter {
    function mint(address to, uint256 value) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.10;
import "erc20.sol";
/**
 *  Token
 *
 * ERC-20 implementation, with mint & burn
 */
contract Token is IERC20 {
    address internal owner;
    address internal pendingOwner;
    address internal issuer;
    uint8 public decimals;
    uint256 public totalSupply;
    uint256 internal maxSupply;
    mapping (address => uint256) public override balanceOf;
    mapping (address => mapping (address => uint256)) public override allowance;
    string public name;
    string public symbol;
    event NewIssuer(address indexed issuer);
    event TransferOwnership(address indexed owner, bool indexed confirmed);
    modifier only(address role) {
        require(msg.sender == role); // dev: missing role
        _;
    }
    /**
     * Sets the token fields: name, symbol and decimals
     *
     * @param tokenName Name of the token
     * @param tokenSymbol Token Symbol
     * @param tokenDecimals Decimal places
     * @param tokenOwner Token Owner
     * @param tokenIssuer Token Issuer
     * @param tokenMaxSupply Max total supply
     */
    constructor(string memory tokenName, string memory tokenSymbol, uint8 tokenDecimals, address tokenOwner, address tokenIssuer, uint256 tokenMaxSupply) {
        require(tokenOwner != address(0)); // dev: invalid owner
        require(tokenIssuer != address(0)); // dev: invalid issuer
        require(tokenMaxSupply > 0); // dev: invalid max supply
        name = tokenName;
        symbol = tokenSymbol;
        decimals = tokenDecimals;
        owner = tokenOwner;
        issuer = tokenIssuer;
        maxSupply = tokenMaxSupply;
    }
    /**
     * Sets the owner
     *
     * @param newOwner Address of the new owner (must be confirmed by the new owner)
     */
    function transferOwnership(address newOwner)
    external
    only(owner) {
        pendingOwner = newOwner;
        emit TransferOwnership(pendingOwner, false);
    }
    /**
     * Confirms the new owner
     */
    function confirmOwnership()
    external
    only(pendingOwner) {
        owner = pendingOwner;
        pendingOwner = address(0);
        emit TransferOwnership(owner, true);
    }
    /**
     * Sets the issuer
     *
     * @param newIssuer Address of the issuer
     */
    function setIssuer(address newIssuer)
    external
    only(owner) {
        issuer = newIssuer;
        emit NewIssuer(issuer);
    }
    /**
     * Mints {value} tokens to the {to} wallet.
     *
     * @param to The address receiving the newly minted tokens
     * @param value The number of tokens to mint
     */
    function mint(address to, uint256 value)
    external
    only(issuer) {
        require(to != address(0)); // dev: requires non-zero address
        require(totalSupply + value <= maxSupply); // dev: exceeds max supply
        unchecked {
            totalSupply += value;
            balanceOf[to] += value;
        }
        emit Transfer(address(0), to, value);
    }
    /**
     * Approves the {spender} to transfer {value} tokens of the caller.
     *
     * @param spender The address which will spend the funds
     * @param value The value approved to be spent by the spender
     * @return A boolean that indicates if the operation was successful
     */
    function approve(address spender, uint256 value)
    external
    override
    returns(bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }
    /**
     * Transfers {value} tokens from the caller, to {to}
     *
     * @param to The address to transfer tokens to
     * @param value The number of tokens to be transferred
     * @return A boolean that indicates if the operation was successful
     */
    function transfer(address to, uint256 value)
    external
    override
    returns (bool) {
        updateBalance(msg.sender, to, value);
        return true;
    }
    /**
     * Transfers {value} tokens of {from} to {to}, on behalf of the caller.
     *
     * @param from The address to transfer tokens from
     * @param to The address to transfer tokens to
     * @param value The number of tokens to be transferred
     * @return A boolean that indicates if the operation was successful
     */
    function transferFrom(address from, address to, uint256 value)
    external
    override
    returns (bool) {
        require(allowance[from][msg.sender] >= value); // dev: exceeds allowance
        updateBalance(from, to, value);
        unchecked {
            allowance[from][msg.sender] -= value;
        }
        return true;
    }
    function updateBalance(address from, address to, uint256 value)
    internal {
        require(to != address(0)); // dev: requires non-zero address
        require(balanceOf[from] >= value); // dev: exceeds balance
        unchecked {
            balanceOf[from] -= value;
            balanceOf[to] += value;
        }
        emit Transfer(from, to, value);
    }
}// SPDX-License-Identifier: MIT
pragma solidity >=0.4.0;
interface IERC20 {
    function totalSupply() external view returns (uint);
    function balanceOf(address account) external view returns (uint);
    function transfer(address recipient, uint amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint amount) external returns (bool);
    function approve(address spender, uint amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint);
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
}