Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

import {ECDSA} from "ECDSA.sol";
import {EIP712} from "EIP712.sol";

import {NftId} from "IChainNft.sol";


contract StakingMessageHelper is 
    EIP712
{
    string public constant EIP712_DOMAIN_NAME = "EtheriscStaking";
    string public constant EIP712_DOMAIN_VERSION = "1";

    // hint: user defined data typs don't work here, NftId -> uint96
    string public constant EIP712_STAKE_TYPE = "Stake(uint96 target,uint256 dipAmount,bytes32 signatureId)";
    bytes32 private constant EIP712_STAKE_TYPE_HASH = keccak256(abi.encodePacked(EIP712_STAKE_TYPE));

    string public constant EIP712_RESTAKE_TYPE = "Restake(uint96 stakeId,uint96 newTarget,bytes32 signatureId)";
    bytes32 private constant EIP712_RESTAKE_TYPE_HASH = keccak256(abi.encodePacked(EIP712_RESTAKE_TYPE));


    mapping(bytes32 signatureHash => bool isUsed) private _signatureIsUsed;


    constructor()
        EIP712(EIP712_DOMAIN_NAME, EIP712_DOMAIN_VERSION)
    // solhint-disable-next-line no-empty-blocks
    { }


    function processStakeSignature(
        address owner,
        NftId target,
        uint256 dipAmount,
        bytes32 signatureId, // ensures unique signatures even when all other attributes are equal
        bytes calldata signature
    )
        external 
    {
        bytes32 digest = getStakeDigest(target, dipAmount, signatureId);
        address signer = getSigner(digest, signature);

        _processSignature(owner, signer ,signature);
    }


    function processRestakeSignature(
        address owner,
        NftId stakeId,
        NftId newTarget,
        bytes32 signatureId, // ensures unique signatures even when all other attributes are equal
        bytes calldata signature
    )
        external 
    {
        bytes32 digest = getRestakeDigest(stakeId, newTarget, signatureId);
        address signer = getSigner(digest, signature);

        _processSignature(owner, signer ,signature);
    }


    function getStakeDigest(
        NftId target,
        uint256 dipAmount,
        bytes32 signatureId
    )
        public
        view
        returns(bytes32 digest)
    {
        bytes32 structHash = keccak256(
            abi.encode(
                EIP712_STAKE_TYPE_HASH,
                target,
                dipAmount,
                signatureId));

        digest = _hashTypedDataV4(structHash);
    }


    function getRestakeDigest(
        NftId stakeId,
        NftId newTarget,
        bytes32 signatureId
    )
        public
        view
        returns(bytes32 digest)
    {
        bytes32 structHash = keccak256(
            abi.encode(
                EIP712_RESTAKE_TYPE_HASH,
                stakeId,
                newTarget,
                signatureId));

        digest = _hashTypedDataV4(structHash);
    }


    function getSigner(
        bytes32 digest,
        bytes calldata signature
    )
        public
        pure
        returns(address signer)
    {
        return ECDSA.recover(digest, signature);
    }


    function _processSignature(
        address owner,
        address signer,
        bytes calldata signature
    )
        internal
    {
        bytes32 signatureHash = keccak256(abi.encode(signature));
        require(!_signatureIsUsed[signatureHash], "ERROR:SMH-001:SIGNATURE_USED");
        require(owner == signer, "ERROR:SMH-002:SIGNATURE_INVALID");
        _signatureIsUsed[signatureHash] = true;
    }    
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // 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), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "Math.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.0;

import "ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

import {IERC721Enumerable} from "IERC721Enumerable.sol";

import {IChainRegistry} from "IChainRegistry.sol";

type NftId is uint96;

using {
    eqNftId as ==,
    neNftId as !=
}
    for NftId global;

function eqNftId(NftId a, NftId b) pure returns(bool isSame) { return NftId.unwrap(a) == NftId.unwrap(b); }
function neNftId(NftId a, NftId b) pure returns(bool isDifferent) { return NftId.unwrap(a) != NftId.unwrap(b); }
function gtz(NftId a) pure returns(bool) { return NftId.unwrap(a) > 0; }
function zeroNftId() pure returns(NftId) { return NftId.wrap(0); }

function toNftId(uint256 tokenId) pure returns(NftId) { return NftId.wrap(uint96(tokenId)); }

interface IChainNft is 
    IERC721Enumerable 
{

    function mint(address to, string memory uri) external returns(uint256 tokenId);
    function burn(uint256 tokenId) external;
    function setURI(uint256 tokenId, string memory uri) external;

    function getRegistry() external view returns(IChainRegistry registry);
    function exists(uint256 tokenId) external view returns(bool);
    function totalMinted() external view returns(uint256);

    function implementsIChainNft() external pure returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

import {IBaseTypes, ChainId, Blocknumber} from "IBaseTypes.sol";
import {Version} from "IVersionType.sol";
import {IVersionable} from "IVersionable.sol";

import {IStaking} from "IStaking.sol";

import {IChainNft, NftId} from "IChainNft.sol";
import {IInstanceServiceFacade} from "IInstanceServiceFacade.sol";

type ObjectType is uint8;

using {
    eqObjectType as ==,
    neObjectType as !=
}
    for ObjectType global;

function eqObjectType(ObjectType a, ObjectType b) pure returns(bool isSame) { return ObjectType.unwrap(a) == ObjectType.unwrap(b); }
function neObjectType(ObjectType a, ObjectType b) pure returns(bool isDifferent) { return ObjectType.unwrap(a) != ObjectType.unwrap(b); }


interface IChainRegistry is 
    IBaseTypes,
    IVersionable
{

    enum ObjectState {
        Undefined,
        Proposed,
        Approved,
        Suspended,
        Archived,
        Burned
    }


    struct NftInfo {
        NftId id;
        ChainId chain;
        ObjectType objectType;
        ObjectState state;
        string uri;
        bytes data;
        Blocknumber mintedIn;
        Blocknumber updatedIn;
        Version version;
    }


    event LogChainRegistryObjectRegistered(NftId id, ChainId chain, ObjectType objectType, ObjectState state, address to);
    event LogChainRegistryObjectStateSet(NftId id, ObjectState stateNew, ObjectState stateOld, address setBy);
    event LogChainRegistryObjectDataUpdated(NftId id, address updatedBy);

    //--- state changing functions ------------------//

    function registerChain(ChainId chain, string memory uri) external returns(NftId id);
    function registerRegistry(ChainId chain, address registry, string memory uri) external returns(NftId id);
    function registerToken(ChainId chain,address token, string memory uri) external returns(NftId id);       


    function registerStake(
        NftId target, 
        address staker
    )
        external
        returns(NftId id);


    function registerInstance(
        address instanceRegistry,
        string memory displayName,
        string memory uri
    )
        external
        returns(NftId id);


    function registerComponent(
        bytes32 instanceId,
        uint256 componentId,
        string memory uri
    )
        external
        returns(NftId id);


    function registerBundle(
        bytes32 instanceId,
        uint256 riskpoolId,
        uint256 bundleId,
        string memory displayName,
        uint256 expiryAt
    )
        external
        returns(NftId id);


    function extendBundleLifetime(NftId id, uint256 lifetimeExtension) external;


    function setObjectState(NftId id, ObjectState state) external;


    //--- view and pure functions ------------------//

    function getNft() external view returns(IChainNft);
    function getStaking() external view returns(IStaking);

    function exists(NftId id) external view returns(bool);

    // generic accessors
    function objects(ChainId chain, ObjectType t) external view returns(uint256 numberOfObjects);
    function getNftId(ChainId chain, ObjectType t, uint256 idx) external view returns(NftId id);
    function getNftInfo(NftId id) external view returns(NftInfo memory);
    function ownerOf(NftId id) external view returns(address nftOwner);

    // chain specific accessors
    function chains() external view returns(uint256 numberOfChains);
    function getChainId(uint256 idx) external view returns(ChainId chain);
    function getChainNftId(ChainId chain) external view returns(NftId id);

    // type specific accessors
    function getRegistryNftId(ChainId chain) external view returns(NftId id);
    function getTokenNftId(ChainId chain, address token) external view returns(NftId id);
    function getInstanceNftId(bytes32 instanceId) external view returns(NftId id);
    function getComponentNftId(bytes32 instanceId, uint256 componentId) external view returns(NftId id);
    function getBundleNftId(bytes32 instanceId, uint256 componentId) external view returns(NftId id);


    function decodeRegistryData(NftId id)
        external
        view
        returns(address registry);


    function decodeTokenData(NftId id)
        external
        view
        returns(address token);


    function decodeInstanceData(NftId id)
        external
        view
        returns(
            bytes32 instanceId,
            address registry,
            string memory displayName);


    function decodeComponentData(NftId id)
        external
        view
        returns(
            bytes32 instanceId,
            uint256 componentId,
            address token);


    function decodeBundleData(NftId id)
        external
        view
        returns(
            bytes32 instanceId,
            uint256 riskpoolId,
            uint256 bundleId,
            address token,
            string memory displayName,
            uint256 expiryAt);


    function decodeStakeData(NftId id)
        external
        view
        returns(
            NftId target,
            ObjectType targetType);


    function toChain(uint256 chainId) 
        external
        pure
        returns(ChainId);

    // only same chain: utility to get reference to instance service for specified instance id
    function getInstanceServiceFacade(bytes32 instanceId) 
        external
        view
        returns(IInstanceServiceFacade instanceService);

    // only same chain:  utilitiv function to probe an instance given its registry address
    function probeInstance(address registry)
        external 
        view 
        returns(
            bool isContract, 
            uint256 contractSize, 
            ChainId chain,
            bytes32 istanceId, 
            bool isValidId, 
            IInstanceServiceFacade instanceService);

    function implementsIChainRegistry() external pure returns(bool);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

// restriction: uint<n> n needs to be different for each type to support function overloading

// allows for chain ids up to 13 digits
type ChainId is bytes5;

using {
    eqChainId as ==,
    neqChainId as !=
}
    for ChainId global;

function eqChainId(ChainId a, ChainId b) pure returns(bool isSame) { return ChainId.unwrap(a) == ChainId.unwrap(b); }
function neqChainId(ChainId a, ChainId b) pure returns(bool isDifferent) { return ChainId.unwrap(a) != ChainId.unwrap(b); }

function toChainId(uint256 chainId) pure returns(ChainId) { return ChainId.wrap(bytes5(uint40(chainId)));}
function thisChainId() view returns(ChainId) { return toChainId(block.chainid); }

type Timestamp is uint40;

using {
    gtTimestamp as >,
    gteTimestamp as >=,
    ltTimestamp as <,
    lteTimestamp as <=,
    eqTimestamp as ==,
    neqTimestamp as !=
}
    for Timestamp global;

function gtTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) > Timestamp.unwrap(b); }
function gteTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) >= Timestamp.unwrap(b); }

function ltTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) < Timestamp.unwrap(b); }
function lteTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) <= Timestamp.unwrap(b); }

function eqTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) == Timestamp.unwrap(b); }
function neqTimestamp(Timestamp a, Timestamp b) pure returns(bool) { return Timestamp.unwrap(a) != Timestamp.unwrap(b); }

function toTimestamp(uint256 timestamp) pure returns(Timestamp) { return Timestamp.wrap(uint40(timestamp));}

// solhint-disable-next-line not-rely-on-time
function blockTimestamp() view returns(Timestamp) { return toTimestamp(block.timestamp); }

function zeroTimestamp() pure returns(Timestamp) { return toTimestamp(0); }

type Blocknumber is uint32;


interface IBaseTypes {

    function intToBytes(uint256 x, uint8 shift) external pure returns(bytes memory);

    function toInt(Blocknumber x) external pure returns(uint);
    function toInt(Timestamp x) external pure returns(uint);
    function toInt(ChainId x) external pure returns(uint);

    function blockNumber() external view returns(Blocknumber);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

// restriction: uint<n> n needs to be different for each type to support function overloading
type VersionPart is uint16;
type Version is uint48; // to concatenate major,minor,patch version parts

using {
    gtVersion as >,
    gteVersion as >=,
    eqVersion as ==
}
    for Version global;

function gtVersion(Version a, Version b) pure returns(bool isGreaterThan) { return Version.unwrap(a) > Version.unwrap(b); }
function gteVersion(Version a, Version b) pure returns(bool isGreaterOrSame) { return Version.unwrap(a) >= Version.unwrap(b); }
function eqVersion(Version a, Version b) pure returns(bool isSame) { return Version.unwrap(a) == Version.unwrap(b); }

function versionPartToInt(VersionPart x) pure returns(uint) { return VersionPart.unwrap(x); }
function versionToInt(Version x) pure returns(uint) { return Version.unwrap(x); }

function toVersionPart(uint16 versionPart) pure returns(VersionPart) { return VersionPart.wrap(versionPart); }

function toVersion(
    VersionPart major,
    VersionPart minor,
    VersionPart patch
)
    pure
    returns(Version)
{
    uint majorInt = versionPartToInt(major);
    uint minorInt = versionPartToInt(minor);
    uint patchInt = versionPartToInt(patch);

    return Version.wrap(
        uint48(
            (majorInt << 32) + (minorInt << 16) + patchInt));
}


function zeroVersion() pure returns(Version) {
    return toVersion(toVersionPart(0), toVersionPart(0), toVersionPart(0));
}


// function toVersionParts(Version _version)
//     pure
//     returns(
//         VersionPart major,
//         VersionPart minor,
//         VersionPart patch
//     )
// {
//     uint versionInt = versionToInt(_version);
//     uint16 majorInt = uint16(versionInt >> 32);

//     versionInt -= majorInt << 32;
//     uint16 minorInt = uint16(versionInt >> 16);
//     uint16 patchInt = uint16(versionInt - (minorInt << 16));

//     return (
//         toVersionPart(majorInt),
//         toVersionPart(minorInt),
//         toVersionPart(patchInt)
//     );
// }

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

import {Blocknumber, Timestamp} from "IBaseTypes.sol";
import {Version, VersionPart} from "IVersionType.sol";

interface IVersionable {

    struct VersionInfo {
        Version version;
        address implementation;
        address activatedBy;
        Blocknumber activatedIn;
        Timestamp activatedAt;
    }

    event LogVersionableActivated(Version version, address implementation, address activatedBy);

    /**
     * @dev IMPORTANT this function needs to be implemented by each new version
     * any such activate implementation needs to call internal function call _activate() 
     * any new version needs to inherit from previous version
     */
    function activate(address implementation, address activatedBy) external;
    function isActivated(Version _version) external view returns(bool);

    function toVersionParts(Version _version)
        external
        pure
        returns(
            VersionPart major,
            VersionPart minor,
            VersionPart patch
        );
    
    // returns current version (ideally immutable)
    function version() external pure returns(Version);
    function versionParts()
        external
        pure
        returns(
            VersionPart major,
            VersionPart minor,
            VersionPart patch
        );

    function versions() external view returns(uint256);
    function getVersion(uint256 idx) external view returns(Version);
    function getVersionInfo(Version _version) external view returns(VersionInfo memory);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

import {IERC20Metadata} from "IERC20Metadata.sol";

import {ChainId, Timestamp} from "IBaseTypes.sol";
import {Version} from "IVersionType.sol";
import {IVersionable} from "IVersionable.sol";

import {UFixed} from "UFixedMath.sol";

import {NftId} from "IChainNft.sol";
import {IChainRegistry, ObjectType} from "IChainRegistry.sol";
import {IInstanceServiceFacade} from "IInstanceServiceFacade.sol";


interface IStaking is
    IVersionable
{

    struct StakeInfo {
        NftId id;
        NftId target;
        uint256 stakeBalance;
        uint256 rewardBalance;
        Timestamp createdAt;
        Timestamp updatedAt;
        Version version;
        Timestamp lockedUntil; // introduced with V03
    }

    event LogStakingWalletChanged(address user, address oldWallet, address newWallet);
    event LogStakingRewardReservesIncreased(address user, uint256 amount, uint256 newBalance);
    event LogStakingRewardReservesDecreased(address user, uint256 amount, uint256 newBalance);

    event LogTargetRewardRateSet(address user, NftId target, UFixed oldRewardRate, UFixed newRewardRate);
    event LogStakingRewardRateSet(address user, UFixed oldRewardRate, UFixed newRewardRate);
    event LogStakingStakingRateSet(address user, ChainId chain, address token, UFixed oldStakingRate, UFixed newStakingRate);

    event LogStakingNewStakeCreated(NftId target, address user, NftId id);
    event LogStakingStaked(NftId target, address user, NftId id, uint256 amount, uint256 newBalance);
    event LogStakingUnstaked(NftId target, address user, NftId id, uint256 amount, uint256 newBalance);
    event LogStakingRestaked(NftId oldTarget, NftId newTrget, address user, NftId stakeId, uint256 stakingAmount);

    event LogStakingRewardsUpdated(NftId id, uint256 amount, uint256 newBalance);
    event LogStakingRewardsClaimed(NftId id, uint256 amount, uint256 newBalance);

    //--- state changing functions ------------------//

    function setStakingWallet(address stakingWalletNew) external;

    function refillRewardReserves(uint256 dipAmount) external;
    function withdrawRewardReserves(uint256 dipAmount) external;

    function setRewardRate(UFixed rewardRate) external;
    function setStakingRate(ChainId chain, address token, UFixed stakingRate) external;    

    function createStake(NftId target, uint256 dipAmount) external returns(NftId id);
    function stake(NftId id, uint256 dipAmount) external;
    function createStakeWithSignature(address owner, NftId target, uint256 dipAmount, bytes32 signatureId, bytes calldata signature) external returns(NftId stakeId);
    function restake(NftId id, NftId newTarget) external;
    function restakeWithSignature(address owner, NftId stakeId, NftId newTarget, bytes32 signatureId, bytes calldata signature) external;
    function unstake(NftId id, uint256 dipAmount) external;  
    function unstakeAndClaimRewards(NftId id) external;
    function claimRewards(NftId id) external;

    //--- view and pure functions ------------------//

    function getRegistry() external view returns(IChainRegistry);
    function getMessageHelperAddress() external view returns(address messageHelperAddress);

    function maxRewardRate() external view returns(UFixed rate);
    function rewardRate() external view returns(UFixed rate);
    function rewardBalance() external view returns(uint256 dipAmount);
    function rewardReserves() external view returns(uint256 dipAmount);
    function getTargetRewardRate(NftId target) external view returns(UFixed rewardRate);

    function stakeBalance() external view returns(uint256 dipAmount);
    function stakingRate(ChainId chain, address token) external view returns(UFixed stakingRate);
    function getStakingWallet() external view returns(address stakingWallet);
    function getDip() external view returns(IERC20Metadata);

    function getInfo(NftId id) external view returns(StakeInfo memory info);

    function stakes(NftId target) external view returns(uint256 dipAmount);
    function capitalSupport(NftId target) external view returns(uint256 capitalAmount);

    function isStakingSupportedForType(ObjectType targetType) external view returns(bool isSupported);
    function isStakingSupported(NftId target) external view returns(bool isSupported);
    function isUnstakingSupported(NftId target) external view returns(bool isSupported);
    function isUnstakingAvailable(NftId stakeId) external view returns(bool isAvailable);

    function calculateRewardsIncrement(StakeInfo memory stakeInfo) external view returns(uint256 rewardsAmount);
    function calculateRewards(uint256 amount, uint256 duration) external view returns(uint256 rewardAmount);

    function calculateRequiredStaking(ChainId chain, address token, uint256 tokenAmount) external view returns(uint256 dipAmount);
    function calculateCapitalSupport(ChainId chain, address token, uint256 dipAmount) external view returns(uint256 tokenAmount);

    function toChain(uint256 chainId) external pure returns(ChainId);

    function toRate(uint256 value, int8 exp) external pure returns(UFixed);
    function rateDecimals() external pure returns(uint256 decimals);

    //--- view and pure functions (target type specific) ------------------//

    function getBundleInfo(NftId bundle)
        external
        view
        returns(
            bytes32 instanceId,
            uint256 riskpoolId,
            uint256 bundleId,
            address token,
            string memory displayName,
            IInstanceServiceFacade.BundleState bundleState,
            Timestamp expiryAt,
            bool stakingSupported,
            bool unstakingSupported,
            uint256 stakeBalance
        );

    function implementsIStaking() external pure returns(bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

import {Math} from "Math.sol";

type UFixed is uint256;

using {
    addUFixed as +,
    subUFixed as -,
    mulUFixed as *,
    divUFixed as /,
    gtUFixed as >,
    gteUFixed as >=,
    ltUFixed as <,
    lteUFixed as <=,
    eqUFixed as ==
}
    for UFixed global;

function addUFixed(UFixed a, UFixed b) pure returns(UFixed) {
    return UFixed.wrap(UFixed.unwrap(a) + UFixed.unwrap(b));
}

function subUFixed(UFixed a, UFixed b) pure returns(UFixed) {
    require(a >= b, "ERROR:UFM-010:NEGATIVE_RESULT");

    return UFixed.wrap(UFixed.unwrap(a) - UFixed.unwrap(b));
}

function mulUFixed(UFixed a, UFixed b) pure returns(UFixed) {
    return UFixed.wrap(Math.mulDiv(UFixed.unwrap(a), UFixed.unwrap(b), 10 ** 18));
}

function divUFixed(UFixed a, UFixed b) pure returns(UFixed) {
    require(UFixed.unwrap(b) > 0, "ERROR:UFM-020:DIVISOR_ZERO");

    return UFixed.wrap(
        Math.mulDiv(
            UFixed.unwrap(a), 
            10 ** 18,
            UFixed.unwrap(b)));
}

function gtUFixed(UFixed a, UFixed b) pure returns(bool isGreaterThan) {
    return UFixed.unwrap(a) > UFixed.unwrap(b);
}

function gteUFixed(UFixed a, UFixed b) pure returns(bool isGreaterThan) {
    return UFixed.unwrap(a) >= UFixed.unwrap(b);
}

function ltUFixed(UFixed a, UFixed b) pure returns(bool isGreaterThan) {
    return UFixed.unwrap(a) < UFixed.unwrap(b);
}

function lteUFixed(UFixed a, UFixed b) pure returns(bool isGreaterThan) {
    return UFixed.unwrap(a) <= UFixed.unwrap(b);
}

function eqUFixed(UFixed a, UFixed b) pure returns(bool isEqual) {
    return UFixed.unwrap(a) == UFixed.unwrap(b);
}

function gtz(UFixed a) pure returns(bool isZero) {
    return UFixed.unwrap(a) > 0;
}

function eqz(UFixed a) pure returns(bool isZero) {
    return UFixed.unwrap(a) == 0;
}

function delta(UFixed a, UFixed b) pure returns(UFixed) {
    if(a > b) {
        return a - b;
    }

    return b - a;
}

contract UFixedType {

    enum Rounding {
        Down, // floor(value)
        Up, // = ceil(value)
        HalfUp // = floor(value + 0.5)
    }

    int8 public constant EXP = 18;
    uint256 public constant MULTIPLIER = 10 ** uint256(int256(EXP));
    uint256 public constant MULTIPLIER_HALF = MULTIPLIER / 2;
    
    Rounding public constant ROUNDING_DEFAULT = Rounding.HalfUp;

    function decimals() public pure returns(uint256) {
        return uint8(EXP);
    }

    function itof(uint256 a)
        public
        pure
        returns(UFixed)
    {
        return UFixed.wrap(a * MULTIPLIER);
    }

    function itof(uint256 a, int8 exp)
        public
        pure
        returns(UFixed)
    {
        require(EXP + exp >= 0, "ERROR:FM-010:EXPONENT_TOO_SMALL");
        require(EXP + exp <= 2 * EXP, "ERROR:FM-011:EXPONENT_TOO_LARGE");

        return UFixed.wrap(a * 10 ** uint8(EXP + exp));
    }

    function ftoi(UFixed a)
        public
        pure
        returns(uint256)
    {
        return ftoi(a, ROUNDING_DEFAULT);
    }

    function ftoi(UFixed a, Rounding rounding)
        public
        pure
        returns(uint256)
    {
        if(rounding == Rounding.HalfUp) {
            return Math.mulDiv(UFixed.unwrap(a) + MULTIPLIER_HALF, 1, MULTIPLIER, Math.Rounding.Down);
        } else if(rounding == Rounding.Down) {
            return Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Down);
        } else {
            return Math.mulDiv(UFixed.unwrap(a), 1, MULTIPLIER, Math.Rounding.Up);
        }
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.19;

import {IERC20Metadata} from "IERC20Metadata.sol";

// needs to be in sync with definition in IInstanceService

interface IComponent {

    function getId() external view returns(uint256);
}


interface IInstanceServiceFacade {

    // needs to be in sync with definition in IComponent
    enum ComponentType {
        Oracle,
        Product,
        Riskpool
    }

    // needs to be in sync with definition in IComponent
    enum ComponentState {
        Created,
        Proposed,
        Declined,
        Active,
        Paused,
        Suspended,
        Archived
    }

    // needs to be in sync with definition in IBundle
    enum BundleState {
        Active,
        Locked,
        Closed,
        Burned
    }

    // needs to be in sync with definition in IBundle
    struct Bundle {
        uint256 id;
        uint256 riskpoolId;
        uint256 tokenId;
        BundleState state;
        bytes filter; // required conditions for applications to be considered for collateralization by this bundle
        uint256 capital; // net investment capital amount (<= balance)
        uint256 lockedCapital; // capital amount linked to collateralizaion of non-closed policies (<= capital)
        uint256 balance; // total amount of funds: net investment capital + net premiums - payouts
        uint256 createdAt;
        uint256 updatedAt;
    }

    function getChainId() external view returns(uint256 chainId);
    function getInstanceId() external view returns(bytes32 instanceId);
    function getInstanceOperator() external view returns(address instanceOperator);

    function getComponent(uint256 componentId) external view returns(IComponent component);
    function getComponentType(uint256 componentId) external view returns(ComponentType componentType);
    function getComponentState(uint256 componentId) external view returns(ComponentState componentState);
    function getComponentToken(uint256 componentId) external view returns(IERC20Metadata token);

    function getBundle(uint256 bundleId) external view returns(Bundle memory bundle);
}

{
  "evmVersion": "istanbul",
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "libraries": {
    "StakingMessageHelper.sol": {}
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"EIP712_DOMAIN_NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EIP712_DOMAIN_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EIP712_RESTAKE_TYPE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EIP712_STAKE_TYPE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"NftId","name":"stakeId","type":"uint96"},{"internalType":"NftId","name":"newTarget","type":"uint96"},{"internalType":"bytes32","name":"signatureId","type":"bytes32"}],"name":"getRestakeDigest","outputs":[{"internalType":"bytes32","name":"digest","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"digest","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"getSigner","outputs":[{"internalType":"address","name":"signer","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"NftId","name":"target","type":"uint96"},{"internalType":"uint256","name":"dipAmount","type":"uint256"},{"internalType":"bytes32","name":"signatureId","type":"bytes32"}],"name":"getStakeDigest","outputs":[{"internalType":"bytes32","name":"digest","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"NftId","name":"stakeId","type":"uint96"},{"internalType":"NftId","name":"newTarget","type":"uint96"},{"internalType":"bytes32","name":"signatureId","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"processRestakeSignature","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"NftId","name":"target","type":"uint96"},{"internalType":"uint256","name":"dipAmount","type":"uint256"},{"internalType":"bytes32","name":"signatureId","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"processStakeSignature","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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