// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

import { OFT20Ticker } from "./../../tokens/ERC20/OFT20Ticker.sol";
import { IGenesisToken } from "./../interface/IGenesisToken.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";

import { IGenesisHub } from "./../IGenesisHub.sol";

contract GenesisToken is OFT20Ticker, IGenesisToken {
  uint256 public constant SECOND_PER_BLOCK = 12;

  address public genesisHub;
  uint32 public lastMintTriggered;

  GenesisConfiguration private configuration;

  constructor(GenesisConstructor memory _args, HeroOFTXOperatorArgs memory _heroArgs)
    OFT20Ticker(_args.name, _args.symbol, _heroArgs.treasury, _args.crossChainFee, _heroArgs)
  {
    lastMintTriggered = uint32(block.timestamp);
    genesisHub = _args.genesisHub;
    configuration = _args.configuration;

    uint256 preMint = _args.preMintAmount;
    if (preMint == 0) return;

    _mint(_heroArgs.treasury, preMint);
    totalMintedSupply += preMint;
  }

  function _onValidatorSameChain(address _to) internal override returns (uint256) {
    return _executeMint(_to, true, 1);
  }

  function _onValidatorCrossChain(address)
    internal
    override
    returns (uint256 tokenIdOrAmount_, uint256 totalMinted_, bool success_)
  {
    tokenIdOrAmount_ = _executeMint(address(0), true, 1);
    return (tokenIdOrAmount_, tokenIdOrAmount_, tokenIdOrAmount_ != 0);
  }

  function redeem(address _to, uint256 _multiplier) external override returns (uint256 rewardMinted_) {
    if (msg.sender != genesisHub) revert NotgenesisHub();
    if (address(key) != address(0) && key.balanceOf(_to) == 0) revert NoKeyDetected();

    rewardMinted_ = _executeMint(address(0), false, _multiplier);
    totalMintedSupply += rewardMinted_;

    _mint(_to, rewardMinted_);

    emit TokenRedeemed(_to, rewardMinted_);
    return rewardMinted_;
  }

  function _executeMint(address _to, bool _isMining, uint256 _multiplier) internal returns (uint256 reward_) {
    reward_ = _calculateTokensToEmit(uint32(block.timestamp), _isMining, _multiplier);
    lastMintTriggered = uint32(block.timestamp);

    if (_to != address(0)) _mint(_to, reward_);

    return reward_;
  }

  function getNextReward(uint256 _multiplier)
    external
    view
    override
    returns (uint256 redeemReward_, uint256 blockProducingReward_)
  {
    if (_multiplier == 0) _multiplier = 1;

    redeemReward_ = _calculateTokensToEmit(uint32(block.timestamp), false, _multiplier);
    blockProducingReward_ = _calculateTokensToEmit(uint32(block.timestamp), true, _multiplier);

    return (redeemReward_, blockProducingReward_);
  }

  function _calculateTokensToEmit(uint32 _timestamp, bool _withBonus, uint256 _multiplier)
    internal
    view
    returns (uint256 minting_)
  {
    GenesisConfiguration memory config = configuration;
    uint256 bonus = 0;

    if (_withBonus) {
      uint256 bonusRate = config.maxBonusFullDay / 1 days;
      uint256 timePassed = (_timestamp - lastMintTriggered);

      bonus = timePassed * bonusRate;
    }

    minting_ = IGenesisHub(genesisHub).applyDifficulty(config.fixedRate * _multiplier);
    minting_ += Math.min(bonus, config.maxBonusFullDay);

    uint256 totalMintedSupplyCached = totalMintedSupply;
    uint256 maxSupplyCached = maxSupply;

    if (totalMintedSupplyCached >= maxSupplyCached) return 0;
    if (totalMintedSupplyCached + minting_ <= maxSupplyCached) return minting_;

    return maxSupplyCached - totalMintedSupplyCached;
  }

  function updateConfiguration(GenesisConfiguration calldata _configuration) external onlyOwner {
    configuration = _configuration;
    emit ConfigurationUpdated(_configuration);
  }

  function updateGenesisHub(address _genesisHub) external onlyOwner {
    genesisHub = _genesisHub;
    emit genesisHubUpdated(_genesisHub);
  }

  function getConfiguration() external view override returns (GenesisConfiguration memory) {
    return configuration;
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { HeroOFTXOperator } from "../extension/HeroOFTXOperator.sol";
import { BaseOFT20, ERC20 } from "./BaseOFT20.sol";

import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";

/**
 * @title OFT20Ticker
 * @notice ERC20 + LZv2 + TickerOperator
 * @dev You will need to implements the following functions
 * - _onValidatorSameChain(address _to)
 * - _onValidatorCrossChain(address _to)
 */
abstract contract OFT20Ticker is BaseOFT20, HeroOFTXOperator {
  error FeeTooHigh();
  error EmptyFeeCollector();

  uint256 public constant MAX_BPS = 10_000;

  uint32 public crossChainFee;
  address public feeCollector;

  constructor(
    string memory _name,
    string memory _symbol,
    address _feeCollector,
    uint32 _crossChainFee,
    HeroOFTXOperatorArgs memory _heroArgs
  ) ERC20(_name, _symbol) HeroOFTXOperator(_heroArgs) BaseOFT20(18) {
    crossChainFee = _crossChainFee;
    feeCollector = _feeCollector;

    if (_feeCollector == address(0)) revert EmptyFeeCollector();
  }

  function _onValidatorCrossChainFailed(address _to, uint256 _amount) internal override {
    _mint(_to, _amount);
  }

  function _toLocalDecimals(uint64 _value) internal view override returns (uint256) {
    return _toLD(_value);
  }

  function _toSharedDecimals(uint256 _value) internal view override returns (uint64) {
    return _toSD(_value);
  }

  function _credit(address _to, uint256 _value, bool _isFrozen) internal override returns (uint256) {
    if (_isFrozen) return _value;

    _mint(_to, _value);

    return _value;
  }

  function _debit(uint256 _amountIn, uint256 _minAmountOut)
    internal
    virtual
    override
    returns (uint256 amountReceiving_)
  {
    (uint256 amountSentLD, uint256 amountReceivedLD) = _debitView(_amountIn, _minAmountOut);

    if (amountReceivedLD < amountSentLD) {
      _mint(feeCollector, amountSentLD - amountReceivedLD);
    }

    _burn(msg.sender, amountSentLD);

    return amountReceivedLD;
  }

  function _debitView(uint256 _amountLD, uint256 _minAmountLD)
    internal
    view
    override
    returns (uint256 amountSentLD, uint256 amountReceivedLD)
  {
    amountSentLD = _removeDust(_amountLD);
    amountReceivedLD = amountSentLD - Math.mulDiv(amountSentLD, crossChainFee, MAX_BPS);

    if (amountReceivedLD < _minAmountLD) {
      revert SlippageExceeded(amountReceivedLD, _minAmountLD);
    }

    return (amountSentLD, amountReceivedLD);
  }

  function updateCrossChainFee(uint32 _fee) external onlyOwner {
    if (_fee > 1000) revert FeeTooHigh();
    crossChainFee = _fee;
  }

  function updateFeeCollector(address _feeCollector) external onlyOwner {
    if (_feeCollector == address(0)) revert EmptyFeeCollector();
    feeCollector = _feeCollector;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

interface IGenesisToken {
  struct GenesisConfiguration {
    uint256 fixedRate;
    uint256 maxBonusFullDay;
  }

  struct GenesisConstructor {
    string name;
    string symbol;
    uint32 crossChainFee;
    uint256 preMintAmount;
    address genesisHub;
    GenesisConfiguration configuration;
  }

  error NoRedeemTokenDectected();
  error RewardLowerThanMinimumAllowed();
  error NoRewardCurrently();
  error RedeemDecayTooHigh();
  error NoKeyDetected();
  error NotgenesisHub();

  event TokenRedeemed(address indexed from, uint256 reward);
  event ConfigurationUpdated(GenesisConfiguration configuration);
  event genesisHubUpdated(address genesisHub);

  function redeem(address _to, uint256 _multiplier) external returns (uint256 rewardMinted_);
  function getNextReward(uint256 _multiplier)
    external
    view
    returns (uint256 redeemReward_, uint256 blockProducingReward_);
  function getConfiguration() external view returns (GenesisConfiguration memory);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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 towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (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 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 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.

            uint256 twos = denominator & (0 - denominator);
            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 (unsignedRoundsUp(rounding) && 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
     * towards zero.
     *
     * 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * 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 256, 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

interface IGenesisHub {
  struct RedeemSettings {
    address tokenInput;
    uint256 ratePerRedeem;
  }

  error InvalidDifficulty();

  event RedeemToken(address indexed caller, address indexed token, uint256 reward);
  event RedeemSettingUpdated(address indexed token, RedeemSettings settings);
  event GlobalDifficultyUpdated(uint256 difficulty);

  function redeem(address _genesisToken, uint256 _redeemMultiplier) external;

  function getRedeemSettings(address _genesisToken) external view returns (RedeemSettings memory);

  function applyDifficulty(uint256 _reward) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { HeroOFTX, OApp } from "../HeroOFTX.sol";
import { IHeroOFTXOperator, IKey } from "./IHeroOFTXOperator.sol";
import { HeroOFTXCallbacksOperator } from "./HeroOFTXCallbacksOperator.sol";
import { TickerOperator } from "heroglyph-library/TickerOperator.sol";

import { MessagingFee, Origin } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/OApp.sol";
import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

/**
 * @title HeroOFTXOperator
 * @notice Base OFT LZv2 with TickerOperation support
 */
abstract contract HeroOFTXOperator is IHeroOFTXOperator, HeroOFTXCallbacksOperator, HeroOFTX, TickerOperator {
  bytes public constant ERROR_LZ_RETURNED_FALSE = hex"29870d9e"; //NotEnoughToLayerZeroFee.selector

  IKey public immutable key;

  address public wrappedNative;
  uint256 private latestBlockMinted;
  uint256 public totalMintedSupply;
  uint256 public maxSupply;
  address public treasury;
  uint32 public immutable localLzEndpointID;

  mapping(uint32 srcLzEndpoint => mapping(address => RequireAction[])) private requireActions;

  constructor(HeroOFTXOperatorArgs memory _heroArgs)
    TickerOperator(_heroArgs.owner, _heroArgs.heroglyphRelay, _heroArgs.feePayer)
    HeroOFTX(_heroArgs.lzGasLimit)
    OApp(_heroArgs.localLzEndpoint, _heroArgs.owner)
  {
    wrappedNative = _heroArgs.wrappedNative;
    key = IKey(_heroArgs.key);

    treasury = _heroArgs.treasury;
    maxSupply = _heroArgs.maxSupply;

    if (maxSupply == 0) maxSupply = type(uint256).max;

    localLzEndpointID = _heroArgs.localLzEndpointID;
  }

  function onValidatorTriggered(
    uint32 _lzEndpointSelected,
    uint32 _blockMinted,
    address _validatorWithdrawer,
    uint128 _feeToRepay
  ) external override onlyRelay {
    //Avoid People from multi-ticker with a graffiti
    if (_blockMinted <= latestBlockMinted) return;
    if (address(key) != address(0) && key.balanceOf(_validatorWithdrawer) == 0) return;

    latestBlockMinted = _blockMinted;

    uint256 totalMinted;

    if (_lzEndpointSelected != localLzEndpointID) {
      totalMinted = _validatorCrosschain(_lzEndpointSelected, _validatorWithdrawer);
    } else {
      totalMinted = _onValidatorSameChain(_validatorWithdrawer);
    }

    totalMintedSupply += totalMinted;

    _repayHeroglyph(_feeToRepay);
  }

  function _validatorCrosschain(uint32 _lzDstEndpointId, address _to) internal virtual returns (uint256 totalMinted_) {
    (uint256 tokenIdOrAmount, uint256 totalMinted, bool success) = _onValidatorCrossChain(_to);
    if (!success) return 0;

    bool lzSuccess;
    bytes memory error_;

    try this.validatorLZSend(_lzDstEndpointId, _to, tokenIdOrAmount) returns (bool success_) {
      lzSuccess = success_;

      if (!success_) {
        error_ = ERROR_LZ_RETURNED_FALSE;
      }
    } catch (bytes memory returnedError) {
      error_ = returnedError;
    }

    if (!lzSuccess) {
      _onValidatorCrossChainFailed(_to, tokenIdOrAmount);
      emit OnCrossChainCallFails(_to, tokenIdOrAmount, error_);
    }

    return totalMinted;
  }

  /**
   * @notice Allows for try-catch to prevent validators from missing their rewards due to fee/LZ issues.
   */
  function validatorLZSend(uint32 _lzDstEndpointId, address _to, uint256 _amount) external returns (bool success_) {
    if (msg.sender != address(this)) revert NoPermission();
    bytes memory options = defaultLzOption;
    uint64 shareChainValue = _toSharedDecimals(_amount);

    bytes memory payload = abi.encode(_to, shareChainValue, 1e18);
    MessagingFee memory fee = _quote(_lzDstEndpointId, payload, options, false);

    payload = abi.encode(_to, shareChainValue, fee.nativeFee);

    //Returning false is cheaper than reverting
    if (!_askFeePayerToPay(address(this), uint128(fee.nativeFee))) return false;

    _lzSend(_lzDstEndpointId, payload, options, fee, payable(getFeePayer()));
    return true;
  }

  function _lzReceive(
    Origin calldata _origin,
    bytes32 _guid,
    bytes calldata _message,
    address, /*_executor*/ // @dev unused in the default implementation.
    bytes calldata /*_extraData*/ // @dev unused in the default implementation.
  ) internal virtual override {
    (address to, uint64 idOrAmount, uint256 fee) = abi.decode(_message, (address, uint64, uint256));
    uint256 amountLD = _toLocalDecimals(idOrAmount);
    if (fee != 0) {
      requireActions[_origin.srcEid][to].push(RequireAction(amountLD, uint128(fee)));
    }

    uint256 amountReceivedLD = _credit(to, amountLD, fee > 0);
    emit OFTReceived(_guid, _origin.srcEid, to, amountReceivedLD);
  }

  function claimAction(uint32 _srcLzEndpoint, uint256[] calldata _indexes) external override {
    uint256 feeDue;
    for (uint256 i = 0; i < _indexes.length; i++) {
      feeDue += _executeAction(_srcLzEndpoint, msg.sender, _indexes[i]);
    }

    if (feeDue == 0) revert NoAction();

    if (!ERC20(wrappedNative).transferFrom(msg.sender, treasury, feeDue)) revert FailedToSendWETH();
  }

  function forgiveDebt(uint32 _srcLzEndpoint, address _of, uint256[] calldata _indexes) external override onlyOwner {
    uint256 feeDue;

    for (uint256 i = 0; i < _indexes.length; i++) {
      feeDue += _executeAction(_srcLzEndpoint, _of, _indexes[i]);
    }

    if (feeDue == 0) revert NoAction();
  }

  function _executeAction(uint32 _srcLzEndpoint, address _of, uint256 _index) internal returns (uint256 amountDue_) {
    RequireAction[] storage allActions = requireActions[_srcLzEndpoint][_of];
    uint256 totalActions = allActions.length;

    if (totalActions == 0 || _index >= totalActions) return 0;
    totalActions -= 1;

    RequireAction storage action = allActions[_index];
    uint256 idOrAmount = action.amountOrId;
    amountDue_ = action.fee;

    if (totalActions != _index) {
      allActions[_index] = allActions[totalActions];
    }

    allActions.pop();

    _credit(_of, idOrAmount, false);

    return amountDue_;
  }

  function getActionsFeeTotal(uint32 _srcLzEndpoint, address _of, uint256[] calldata _indexes)
    external
    view
    returns (uint256 amountDue_)
  {
    RequireAction[] storage allActions = requireActions[_srcLzEndpoint][_of];
    uint256 totalActions = allActions.length;
    if (totalActions == 0) return 0;

    uint256 index;

    for (uint256 i = 0; i < _indexes.length; ++i) {
      index = _indexes[i];

      if (index >= totalActions) continue;
      amountDue_ += allActions[index].fee;
    }

    return amountDue_;
  }

  function _generateMessage(address _to, uint256 _amountOrId) internal view override returns (bytes memory) {
    return abi.encode(_to, _toSharedDecimals(_amountOrId), 0);
  }

  function _payNative(uint256 _nativeFee) internal override returns (uint256 nativeFee) {
    uint256 balance = address(this).balance;

    if (msg.value != 0 && msg.value < _nativeFee) revert NotEnoughNative(msg.value);
    if (msg.value == 0 && balance < _nativeFee) revert NotEnoughNative(balance);

    return _nativeFee;
  }

  function retrieveNative(address _to) external onlyOwner {
    (bool success,) = _to.call{ value: address(this).balance }("");
    if (!success) revert FailedToSendETH();
  }

  function updateTreasury(address _treasury) external onlyOwner {
    treasury = _treasury;
    emit TreasuryUpdated(_treasury);
  }

  function updateNativeWrapper(address _wrapper) external onlyOwner {
    wrappedNative = _wrapper;
  }

  function getPendingActions(uint32 _lzEndpointID, address _user)
    external
    view
    override
    returns (RequireAction[] memory)
  {
    return requireActions[_lzEndpointID][_user];
  }

  function getLatestBlockMinted() external view override returns (uint256) {
    return latestBlockMinted;
  }

  function cap() external view returns (uint256) {
    return maxSupply;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import { HeroOFTErrors } from "./../HeroOFTErrors.sol";

/**
 * @title BaseOFT20
 * @notice Copied some part of the OFTCore.sol logic from LZ Codebase
 */
abstract contract BaseOFT20 is ERC20, HeroOFTErrors {
  error InvalidLocalDecimals();

  // @notice Provides a conversion rate when swapping between denominations of SD and LD
  //      - shareDecimals == SD == shared Decimals
  //      - localDecimals == LD == local decimals
  // @dev Considers that tokens have different decimal amounts on various chains.
  // @dev eg.
  //  For a token
  //      - locally with 4 decimals --> 1.2345 => uint(12345)
  //      - remotely with 2 decimals --> 1.23 => uint(123)
  //      - The conversion rate would be 10 ** (4 - 2) = 100
  //  @dev If you want to send 1.2345 -> (uint 12345), you CANNOT represent that value on the remote,
  //  you can only display 1.23 -> uint(123).
  //  @dev To preserve the dust that would otherwise be lost on that conversion,
  //  we need to unify a denomination that can be represented on ALL chains inside of the OFT mesh
  uint256 public immutable decimalConversionRate;

  constructor(uint8 _decimals) {
    if (_decimals < sharedDecimals()) revert InvalidLocalDecimals();
    decimalConversionRate = 10 ** (_decimals - sharedDecimals());
  }

  /**
   * @dev Retrieves the shared decimals of the OFT.
   * @return The shared decimals of the OFT.
   *
   * @dev Sets an implicit cap on the amount of tokens, over uint64.max() will need some sort of outbound cap /
   * totalSupply cap
   * Lowest common decimal denominator between chains.
   * Defaults to 6 decimal places to provide up to 18,446,744,073,709.551615 units (max uint64).
   * For tokens exceeding this totalSupply(), they will need to override the sharedDecimals function with something
   * smaller.
   * ie. 4 sharedDecimals would be 1,844,674,407,370,955.1615
   */
  function sharedDecimals() public pure virtual returns (uint8) {
    return 6;
  }

  function _debitView(uint256 _amountLD, uint256 _minAmountLD)
    internal
    view
    virtual
    returns (uint256 amountSentLD, uint256 amountReceivedLD)
  {
    amountSentLD = _removeDust(_amountLD);
    amountReceivedLD = amountSentLD;

    if (amountReceivedLD < _minAmountLD) {
      revert SlippageExceeded(amountReceivedLD, _minAmountLD);
    }

    return (amountSentLD, amountReceivedLD);
  }

  /**
   * @dev Internal function to remove dust from the given local decimal amount.
   * @param _amountLD The amount in local decimals.
   * @return amountLD The amount after removing dust.
   *
   * @dev Prevents the loss of dust when moving amounts between chains with different decimals.
   * @dev eg. uint(123) with a conversion rate of 100 becomes uint(100).
   */
  function _removeDust(uint256 _amountLD) internal view virtual returns (uint256 amountLD) {
    return (_amountLD / decimalConversionRate) * decimalConversionRate;
  }

  /**
   * @dev Internal function to convert an amount from shared decimals into local decimals.
   * @param _amountSD The amount in shared decimals.
   * @return amountLD The amount in local decimals.
   */
  function _toLD(uint64 _amountSD) internal view virtual returns (uint256 amountLD) {
    return _amountSD * decimalConversionRate;
  }

  /**
   * @dev Internal function to convert an amount from local decimals into shared decimals.
   * @param _amountLD The amount in local decimals.
   * @return amountSD The amount in shared decimals.
   */
  function _toSD(uint256 _amountLD) internal view virtual returns (uint64 amountSD) {
    return uint64(_amountLD / decimalConversionRate);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IHeroOFTX } from "./IHeroOFTX.sol";
import { HeroOFTXCallbacks } from "./HeroOFTXCallbacks.sol";
import { HeroOFTErrors } from "./HeroOFTErrors.sol";

import { OApp, MessagingFee, MessagingReceipt, Origin } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/OApp.sol";
import { OptionsBuilder } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oapp/libs/OptionsBuilder.sol";

/**
 * @title HeroOFTX
 * @notice Base OFT LZv2 with TickerOperation support
 */
abstract contract HeroOFTX is IHeroOFTX, HeroOFTXCallbacks, OApp, HeroOFTErrors {
  using OptionsBuilder for bytes;

  uint32 public lzGasLimit;
  bytes public defaultLzOption;

  constructor(uint32 _lzGasLimit) {
    _updateLayerZeroGasLimit(_lzGasLimit);
  }

  function send(uint32 _dstEid, address _to, uint256 _amountIn, uint256 _minAmountOut)
    external
    payable
    returns (MessagingReceipt memory msgReceipt)
  {
    bytes memory option = defaultLzOption;
    uint256 amountOrIdReceiving = _debit(_amountIn, _minAmountOut);

    if (amountOrIdReceiving < _minAmountOut) {
      revert SlippageExceeded(amountOrIdReceiving, _minAmountOut);
    }

    bytes memory payload = _generateMessage(_to, amountOrIdReceiving);
    MessagingFee memory fee = _estimateFee(_dstEid, payload, option);

    msgReceipt = _lzSend(_dstEid, payload, option, fee, payable(msg.sender));

    emit OFTSent(msgReceipt.guid, _dstEid, msg.sender, amountOrIdReceiving);

    return msgReceipt;
  }

  function _lzReceive(
    Origin calldata _origin,
    bytes32 _guid,
    bytes calldata _message,
    address, /*_executor*/ // @dev unused in the default implementation.
    bytes calldata /*_extraData*/ // @dev unused in the default implementation.
  ) internal virtual override {
    (address to, uint64 idOrAmount) = abi.decode(_message, (address, uint64));
    uint256 amountReceivedLD = _credit(to, _toLocalDecimals(idOrAmount), false);

    emit OFTReceived(_guid, _origin.srcEid, to, amountReceivedLD);
  }

  /**
   * @notice _toLocalDecimals Scale back to local chain decimals
   * @param _value Value from the message
   * @dev This function must be overridden by ERCs that handle high balances
   * @dev For ERC721, this won't be an issue since there are no collections that reach uint64.max
   * @dev Refer to BaseERC20.sol for more details.
   */
  function _toLocalDecimals(uint64 _value) internal view virtual returns (uint256) {
    return _value;
  }

  function estimateFee(uint32 _dstEid, address _to, uint256 _tokenId) external view returns (uint256) {
    return _estimateFee(_dstEid, _generateMessage(_to, _tokenId), defaultLzOption).nativeFee;
  }

  function _generateMessage(address _to, uint256 _amountOrId) internal view virtual returns (bytes memory) {
    return abi.encode(_to, _toSharedDecimals(_amountOrId));
  }

  function _estimateFee(uint32 _dstEid, bytes memory _message, bytes memory _options)
    internal
    view
    returns (MessagingFee memory fee_)
  {
    return _quote(_dstEid, _message, _options, false);
  }

  /**
   * @notice _toSharedDecimals Scale back to share chain decimals, some chains only support 6 decimals
   * @param _value Amount sending to another chain
   * @dev This function must be overridden by ERCs that handle high balances
   * @dev For ERC721, this won't be an issue since there are no collections that reach uint64.max
   * @dev Refer to BaseERC20.sol for more details.
   */
  function _toSharedDecimals(uint256 _value) internal view virtual returns (uint64) {
    if (_value > type(uint64).max) revert ConversionOutOfBounds();

    return uint64(_value);
  }

  /**
   * @notice updateLayerZeroGasLimit Set a new gas limit for LZ
   * @param _lzGasLimit gas limit of a LZ Message execution
   */
  function updateLayerZeroGasLimit(uint32 _lzGasLimit) external virtual onlyOwner {
    _updateLayerZeroGasLimit(_lzGasLimit);
  }

  function _updateLayerZeroGasLimit(uint32 _lzGasLimit) internal virtual {
    if (_lzGasLimit == 0) revert GasLimitCannotBeZero();

    lzGasLimit = _lzGasLimit;
    defaultLzOption = OptionsBuilder.newOptions().addExecutorLzReceiveOption(lzGasLimit, 0);
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

/**
 * @title IKey
 * @author A key is most-likely an NFT, but it can be whatever that support balanceOf
 */
interface IKey {
  function balanceOf(address account) external view returns (uint256);
}

interface IHeroOFTXOperator {
  error NoAction();
  error NoPermission();
  error FailedToSendWETH();
  error NotEnoughToLayerZeroFee();

  event TreasuryUpdated(address indexed treasury);

  struct RequireAction {
    uint256 amountOrId;
    uint128 fee;
  }

  struct HeroOFTXOperatorArgs {
    address wrappedNative;
    address key;
    address owner;
    address treasury;
    address feePayer;
    address heroglyphRelay;
    address localLzEndpoint;
    uint32 localLzEndpointID;
    uint32 lzGasLimit;
    uint256 maxSupply;
  }

  event OnCrossChainCallFails(address indexed validator, uint256 amountOrNftId, bytes errorMessage);

  /**
   * @notice claimAction() When a validator sets a cross-chain in graffiti, they have to pay the LZ fee. The asset is
   * frozen and is waiting for the user's action
   * @param _srcLzEndpoint Origin Lz endpoint ID of the asset
   * @param _indexes Array of action indexes to execute in batch decending orders
   */
  function claimAction(uint32 _srcLzEndpoint, uint256[] calldata _indexes) external;

  /**
   * @notice forgiveDebt() The owner of the contract can forgive the debt of a user and execute the pending actions on
   * their behalf.
   * @param _srcLzEndpoint Origin Lz endpoint ID of the asset
   * @param _of Address of the user
   * @param _indexes Array of action indexes to execute in batch decending orders
   */
  function forgiveDebt(uint32 _srcLzEndpoint, address _of, uint256[] calldata _indexes) external;

  /**
   * @notice getPendingActions() Retrieves all pending actions of an address.
   * @param _lzEndpointID Origin LZ Endpoint ID.
   * @param _user Address of the user.
   * @return actions Array of Action tuples (uint256 amountOrId, uint128 fee).
   */
  function getPendingActions(uint32 _lzEndpointID, address _user) external view returns (RequireAction[] memory);

  /**
   * @notice getLatestBlockMinted() Retrieves the latest executed block.
   */
  function getLatestBlockMinted() external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

abstract contract HeroOFTXCallbacksOperator {
  function _onValidatorCrossChainFailed(address _to, uint256 _idOrAmount) internal virtual;
  function _onValidatorSameChain(address _to) internal virtual returns (uint256 totalMinted_);
  function _onValidatorCrossChain(address _to)
    internal
    virtual
    returns (uint256 tokenIdOrAmount_, uint256 totalMinted_, bool success_);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

import { ITickerOperator } from "./ITickerOperator.sol";
import { IGasPool } from "./IGasPool.sol";

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title TickerOperator
 * @notice Template of what a Ticker Contract should have to execute successfully. This can be implemented in your if
 * needed
 */
abstract contract TickerOperator is ITickerOperator, Ownable {
    address public heroglyphRelay;
    address private feePayer;

    modifier onlyRelay() {
        if (msg.sender != address(heroglyphRelay)) revert NotHeroglyph();
        _;
    }

    constructor(address _owner, address _heroglyphRelay, address _feePayer) Ownable(_owner) {
        if (_feePayer == address(0)) _feePayer = address(this);

        feePayer = _feePayer;
        heroglyphRelay = _heroglyphRelay;
    }

    /**
     * @notice _repayHeroglyph repay the HeroglyphRelay contract for executing your code
     * @dev it should be call at the end / near the end of your code. It uses gasLeft() to calculate the
     * cost of the fee.
     */
    function _repayHeroglyph(uint128 _feeToPay) internal virtual {
        if (_feeToPay == 0) return;
        if (!_askFeePayerToPay(address(heroglyphRelay), _feeToPay)) revert FailedToSendETH();
    }

    function _askFeePayerToPay(address _to, uint128 _amount) internal returns (bool success_) {
        if (feePayer != address(this)) {
            IGasPool(feePayer).payTo(_to, _amount);
            return true;
        }

        if (address(this).balance < _amount) return false;
        if (_to == address(this)) return true;

        (success_,) = _to.call{ value: _amount }("");
        return success_;
    }

    function updateHeroglyphRelay(address _relay) external onlyOwner {
        heroglyphRelay = _relay;
        emit HeroglyphRelayUpdated(_relay);
    }

    function updateFeePayer(address _feePayer) external onlyOwner {
        _updateFeePayer(_feePayer);
    }

    function _updateFeePayer(address _feePayer) internal virtual {
        if (_feePayer == address(0)) revert FeePayerCannotBeZero();

        feePayer = _feePayer;
        emit FeePayerUpdated(_feePayer);
    }

    function getFeePayer() public view virtual returns (address) {
        return feePayer;
    }

    receive() external payable virtual { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

// @dev Import the 'MessagingFee' and 'MessagingReceipt' so it's exposed to OApp implementers
// solhint-disable-next-line no-unused-import
import { OAppSender, MessagingFee, MessagingReceipt } from "./OAppSender.sol";
// @dev Import the 'Origin' so it's exposed to OApp implementers
// solhint-disable-next-line no-unused-import
import { OAppReceiver, Origin } from "./OAppReceiver.sol";
import { OAppCore } from "./OAppCore.sol";

/**
 * @title OApp
 * @dev Abstract contract serving as the base for OApp implementation, combining OAppSender and OAppReceiver functionality.
 */
abstract contract OApp is OAppSender, OAppReceiver {
    /**
     * @dev Constructor to initialize the OApp with the provided endpoint and owner.
     * @param _endpoint The address of the LOCAL LayerZero endpoint.
     * @param _delegate The delegate capable of making OApp configurations inside of the endpoint.
     */
    constructor(address _endpoint, address _delegate) OAppCore(_endpoint, _delegate) {}

    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol implementation.
     * @return receiverVersion The version of the OAppReceiver.sol implementation.
     */
    function oAppVersion()
        public
        pure
        virtual
        override(OAppSender, OAppReceiver)
        returns (uint64 senderVersion, uint64 receiverVersion)
    {
        return (SENDER_VERSION, RECEIVER_VERSION);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

interface HeroOFTErrors {
  error GasLimitCannotBeZero();
  error SlippageExceeded(uint256 amountLD, uint256 minAmountLD);
  error ConversionOutOfBounds();
}

// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0;

interface IHeroOFTX {
  event OFTSent(bytes32 indexed guid, uint32 indexed destinationEndpointId, address indexed to, uint256 amountOrId);
  event OFTReceived(bytes32 indexed guid, uint32 indexed sourceEndpointId, address indexed to, uint256 amountOrId);

  /**
   * @notice Estimate Cross-chain fee
   * @param _dstEid Destination LZ Endpoint ID
   * @param _to Receiver of the asset
   * @param _tokenIdOrAmount NFT ID or Amount of the Token sending
   */
  function estimateFee(uint32 _dstEid, address _to, uint256 _tokenIdOrAmount) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

abstract contract HeroOFTXCallbacks {
  function _debit(uint256 _amountOrId, uint256 _minAmount) internal virtual returns (uint256 _amountSendingOrId_);
  function _credit(address _to, uint256 _value, bool _isFrozen) internal virtual returns (uint256 amountReceived_);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { BytesLib } from "solidity-bytes-utils/contracts/BytesLib.sol";
import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";

import { ExecutorOptions } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/ExecutorOptions.sol";
import { DVNOptions } from "@layerzerolabs/lz-evm-messagelib-v2/contracts/uln/libs/DVNOptions.sol";

/**
 * @title OptionsBuilder
 * @dev Library for building and encoding various message options.
 */
library OptionsBuilder {
    using SafeCast for uint256;
    using BytesLib for bytes;

    // Constants for options types
    uint16 internal constant TYPE_1 = 1; // legacy options type 1
    uint16 internal constant TYPE_2 = 2; // legacy options type 2
    uint16 internal constant TYPE_3 = 3;

    // Custom error message
    error InvalidSize(uint256 max, uint256 actual);
    error InvalidOptionType(uint16 optionType);

    // Modifier to ensure only options of type 3 are used
    modifier onlyType3(bytes memory _options) {
        if (_options.toUint16(0) != TYPE_3) revert InvalidOptionType(_options.toUint16(0));
        _;
    }

    /**
     * @dev Creates a new options container with type 3.
     * @return options The newly created options container.
     */
    function newOptions() internal pure returns (bytes memory) {
        return abi.encodePacked(TYPE_3);
    }

    /**
     * @dev Adds an executor LZ receive option to the existing options.
     * @param _options The existing options container.
     * @param _gas The gasLimit used on the lzReceive() function in the OApp.
     * @param _value The msg.value passed to the lzReceive() function in the OApp.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed by the executor
     * eg. if (_gas: 200k, and _value: 1 ether) AND (_gas: 100k, _value: 0.5 ether) are sent in an option to the LayerZeroEndpoint,
     * that becomes (300k, 1.5 ether) when the message is executed on the remote lzReceive() function.
     */
    function addExecutorLzReceiveOption(
        bytes memory _options,
        uint128 _gas,
        uint128 _value
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeLzReceiveOption(_gas, _value);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_LZRECEIVE, option);
    }

    /**
     * @dev Adds an executor native drop option to the existing options.
     * @param _options The existing options container.
     * @param _amount The amount for the native value that is airdropped to the 'receiver'.
     * @param _receiver The receiver address for the native drop option.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed by the executor on the remote chain.
     */
    function addExecutorNativeDropOption(
        bytes memory _options,
        uint128 _amount,
        bytes32 _receiver
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeNativeDropOption(_amount, _receiver);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_NATIVE_DROP, option);
    }

    /**
     * @dev Adds an executor LZ compose option to the existing options.
     * @param _options The existing options container.
     * @param _index The index for the lzCompose() function call.
     * @param _gas The gasLimit for the lzCompose() function call.
     * @param _value The msg.value for the lzCompose() function call.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed PER index by the executor on the remote chain.
     * @dev If the OApp sends N lzCompose calls on the remote, you must provide N incremented indexes starting with 0.
     * ie. When your remote OApp composes (N = 3) messages, you must set this option for index 0,1,2
     */
    function addExecutorLzComposeOption(
        bytes memory _options,
        uint16 _index,
        uint128 _gas,
        uint128 _value
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeLzComposeOption(_index, _gas, _value);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_LZCOMPOSE, option);
    }

    /**
     * @dev Adds an executor ordered execution option to the existing options.
     * @param _options The existing options container.
     * @return options The updated options container.
     */
    function addExecutorOrderedExecutionOption(
        bytes memory _options
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_ORDERED_EXECUTION, bytes(""));
    }

    /**
     * @dev Adds a DVN pre-crime option to the existing options.
     * @param _options The existing options container.
     * @param _dvnIdx The DVN index for the pre-crime option.
     * @return options The updated options container.
     */
    function addDVNPreCrimeOption(
        bytes memory _options,
        uint8 _dvnIdx
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return addDVNOption(_options, _dvnIdx, DVNOptions.OPTION_TYPE_PRECRIME, bytes(""));
    }

    /**
     * @dev Adds an executor option to the existing options.
     * @param _options The existing options container.
     * @param _optionType The type of the executor option.
     * @param _option The encoded data for the executor option.
     * @return options The updated options container.
     */
    function addExecutorOption(
        bytes memory _options,
        uint8 _optionType,
        bytes memory _option
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return
            abi.encodePacked(
                _options,
                ExecutorOptions.WORKER_ID,
                _option.length.toUint16() + 1, // +1 for optionType
                _optionType,
                _option
            );
    }

    /**
     * @dev Adds a DVN option to the existing options.
     * @param _options The existing options container.
     * @param _dvnIdx The DVN index for the DVN option.
     * @param _optionType The type of the DVN option.
     * @param _option The encoded data for the DVN option.
     * @return options The updated options container.
     */
    function addDVNOption(
        bytes memory _options,
        uint8 _dvnIdx,
        uint8 _optionType,
        bytes memory _option
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return
            abi.encodePacked(
                _options,
                DVNOptions.WORKER_ID,
                _option.length.toUint16() + 2, // +2 for optionType and dvnIdx
                _dvnIdx,
                _optionType,
                _option
            );
    }

    /**
     * @dev Encodes legacy options of type 1.
     * @param _executionGas The gasLimit value passed to lzReceive().
     * @return legacyOptions The encoded legacy options.
     */
    function encodeLegacyOptionsType1(uint256 _executionGas) internal pure returns (bytes memory) {
        if (_executionGas > type(uint128).max) revert InvalidSize(type(uint128).max, _executionGas);
        return abi.encodePacked(TYPE_1, _executionGas);
    }

    /**
     * @dev Encodes legacy options of type 2.
     * @param _executionGas The gasLimit value passed to lzReceive().
     * @param _nativeForDst The amount of native air dropped to the receiver.
     * @param _receiver The _nativeForDst receiver address.
     * @return legacyOptions The encoded legacy options of type 2.
     */
    function encodeLegacyOptionsType2(
        uint256 _executionGas,
        uint256 _nativeForDst,
        bytes memory _receiver // @dev Use bytes instead of bytes32 in legacy type 2 for _receiver.
    ) internal pure returns (bytes memory) {
        if (_executionGas > type(uint128).max) revert InvalidSize(type(uint128).max, _executionGas);
        if (_nativeForDst > type(uint128).max) revert InvalidSize(type(uint128).max, _nativeForDst);
        if (_receiver.length > 32) revert InvalidSize(32, _receiver.length);
        return abi.encodePacked(TYPE_2, _executionGas, _nativeForDst, _receiver);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0;

interface ITickerOperator {
    error FailedToSendETH();
    error NotHeroglyph();
    error FeePayerCannotBeZero();

    event FeePayerUpdated(address indexed feePayer);
    event HeroglyphRelayUpdated(address relay);

    /**
     * @notice onValidatorTriggered() Callback function when your ticker has been selected
     * @param _lzEndpointSelected // The selected layer zero endpoint target for this ticker
     * @param _blockNumber  // The number of the block minted
     * @param _identityReceiver // The Identity's receiver from the miner graffiti
     * @param _heroglyphFee // The fee to pay for the execution
     * @dev be sure to apply onlyRelay to this function
     * @dev TIP: Avoid using reverts; instead, use return statements, unless you need to restore your contract to its
     * initial state.
     * @dev TIP:Keep in mind that a miner may utilize your ticker more than once in their graffiti. To avoid any
     * repetition, consider utilizing blockNumber to track actions.
     */
    function onValidatorTriggered(
        uint32 _lzEndpointSelected,
        uint32 _blockNumber,
        address _identityReceiver,
        uint128 _heroglyphFee
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity >= 0.8.0;

/**
 * @title IGasPool
 * @notice If you have a community // service pool to pay all fee, it must have this interface integrated
 * @dev is the feePayer is not the contract address, it will fallback to calling IGasPool::payTo()
 */
interface IGasPool {
    function payTo(address _to, uint256 _amount) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { SafeERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { MessagingParams, MessagingFee, MessagingReceipt } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
import { OAppCore } from "./OAppCore.sol";

/**
 * @title OAppSender
 * @dev Abstract contract implementing the OAppSender functionality for sending messages to a LayerZero endpoint.
 */
abstract contract OAppSender is OAppCore {
    using SafeERC20 for IERC20;

    // Custom error messages
    error NotEnoughNative(uint256 msgValue);
    error LzTokenUnavailable();

    // @dev The version of the OAppSender implementation.
    // @dev Version is bumped when changes are made to this contract.
    uint64 internal constant SENDER_VERSION = 1;

    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     *
     * @dev Providing 0 as the default for OAppReceiver version. Indicates that the OAppReceiver is not implemented.
     * ie. this is a SEND only OApp.
     * @dev If the OApp uses both OAppSender and OAppReceiver, then this needs to be override returning the correct versions
     */
    function oAppVersion() public view virtual returns (uint64 senderVersion, uint64 receiverVersion) {
        return (SENDER_VERSION, 0);
    }

    /**
     * @dev Internal function to interact with the LayerZero EndpointV2.quote() for fee calculation.
     * @param _dstEid The destination endpoint ID.
     * @param _message The message payload.
     * @param _options Additional options for the message.
     * @param _payInLzToken Flag indicating whether to pay the fee in LZ tokens.
     * @return fee The calculated MessagingFee for the message.
     *      - nativeFee: The native fee for the message.
     *      - lzTokenFee: The LZ token fee for the message.
     */
    function _quote(
        uint32 _dstEid,
        bytes memory _message,
        bytes memory _options,
        bool _payInLzToken
    ) internal view virtual returns (MessagingFee memory fee) {
        return
            endpoint.quote(
                MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _payInLzToken),
                address(this)
            );
    }

    /**
     * @dev Internal function to interact with the LayerZero EndpointV2.send() for sending a message.
     * @param _dstEid The destination endpoint ID.
     * @param _message The message payload.
     * @param _options Additional options for the message.
     * @param _fee The calculated LayerZero fee for the message.
     *      - nativeFee: The native fee.
     *      - lzTokenFee: The lzToken fee.
     * @param _refundAddress The address to receive any excess fee values sent to the endpoint.
     * @return receipt The receipt for the sent message.
     *      - guid: The unique identifier for the sent message.
     *      - nonce: The nonce of the sent message.
     *      - fee: The LayerZero fee incurred for the message.
     */
    function _lzSend(
        uint32 _dstEid,
        bytes memory _message,
        bytes memory _options,
        MessagingFee memory _fee,
        address _refundAddress
    ) internal virtual returns (MessagingReceipt memory receipt) {
        // @dev Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
        uint256 messageValue = _payNative(_fee.nativeFee);
        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);

        return
            // solhint-disable-next-line check-send-result
            endpoint.send{ value: messageValue }(
                MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0),
                _refundAddress
            );
    }

    /**
     * @dev Internal function to pay the native fee associated with the message.
     * @param _nativeFee The native fee to be paid.
     * @return nativeFee The amount of native currency paid.
     *
     * @dev If the OApp needs to initiate MULTIPLE LayerZero messages in a single transaction,
     * this will need to be overridden because msg.value would contain multiple lzFees.
     * @dev Should be overridden in the event the LayerZero endpoint requires a different native currency.
     * @dev Some EVMs use an ERC20 as a method for paying transactions/gasFees.
     * @dev The endpoint is EITHER/OR, ie. it will NOT support both types of native payment at a time.
     */
    function _payNative(uint256 _nativeFee) internal virtual returns (uint256 nativeFee) {
        if (msg.value != _nativeFee) revert NotEnoughNative(msg.value);
        return _nativeFee;
    }

    /**
     * @dev Internal function to pay the LZ token fee associated with the message.
     * @param _lzTokenFee The LZ token fee to be paid.
     *
     * @dev If the caller is trying to pay in the specified lzToken, then the lzTokenFee is passed to the endpoint.
     * @dev Any excess sent, is passed back to the specified _refundAddress in the _lzSend().
     */
    function _payLzToken(uint256 _lzTokenFee) internal virtual {
        // @dev Cannot cache the token because it is not immutable in the endpoint.
        address lzToken = endpoint.lzToken();
        if (lzToken == address(0)) revert LzTokenUnavailable();

        // Pay LZ token fee by sending tokens to the endpoint.
        IERC20(lzToken).safeTransferFrom(msg.sender, address(endpoint), _lzTokenFee);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { IOAppReceiver, Origin } from "./interfaces/IOAppReceiver.sol";
import { OAppCore } from "./OAppCore.sol";

/**
 * @title OAppReceiver
 * @dev Abstract contract implementing the ILayerZeroReceiver interface and extending OAppCore for OApp receivers.
 */
abstract contract OAppReceiver is IOAppReceiver, OAppCore {
    // Custom error message for when the caller is not the registered endpoint/
    error OnlyEndpoint(address addr);

    // @dev The version of the OAppReceiver implementation.
    // @dev Version is bumped when changes are made to this contract.
    uint64 internal constant RECEIVER_VERSION = 2;

    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     *
     * @dev Providing 0 as the default for OAppSender version. Indicates that the OAppSender is not implemented.
     * ie. this is a RECEIVE only OApp.
     * @dev If the OApp uses both OAppSender and OAppReceiver, then this needs to be override returning the correct versions.
     */
    function oAppVersion() public view virtual returns (uint64 senderVersion, uint64 receiverVersion) {
        return (0, RECEIVER_VERSION);
    }

    /**
     * @notice Indicates whether an address is an approved composeMsg sender to the Endpoint.
     * @dev _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @dev _message The lzReceive payload.
     * @param _sender The sender address.
     * @return isSender Is a valid sender.
     *
     * @dev Applications can optionally choose to implement separate composeMsg senders that are NOT the bridging layer.
     * @dev The default sender IS the OAppReceiver implementer.
     */
    function isComposeMsgSender(
        Origin calldata /*_origin*/,
        bytes calldata /*_message*/,
        address _sender
    ) public view virtual returns (bool) {
        return _sender == address(this);
    }

    /**
     * @notice Checks if the path initialization is allowed based on the provided origin.
     * @param origin The origin information containing the source endpoint and sender address.
     * @return Whether the path has been initialized.
     *
     * @dev This indicates to the endpoint that the OApp has enabled msgs for this particular path to be received.
     * @dev This defaults to assuming if a peer has been set, its initialized.
     * Can be overridden by the OApp if there is other logic to determine this.
     */
    function allowInitializePath(Origin calldata origin) public view virtual returns (bool) {
        return peers[origin.srcEid] == origin.sender;
    }

    /**
     * @notice Retrieves the next nonce for a given source endpoint and sender address.
     * @dev _srcEid The source endpoint ID.
     * @dev _sender The sender address.
     * @return nonce The next nonce.
     *
     * @dev The path nonce starts from 1. If 0 is returned it means that there is NO nonce ordered enforcement.
     * @dev Is required by the off-chain executor to determine the OApp expects msg execution is ordered.
     * @dev This is also enforced by the OApp.
     * @dev By default this is NOT enabled. ie. nextNonce is hardcoded to return 0.
     */
    function nextNonce(uint32 /*_srcEid*/, bytes32 /*_sender*/) public view virtual returns (uint64 nonce) {
        return 0;
    }

    /**
     * @dev Entry point for receiving messages or packets from the endpoint.
     * @param _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @param _guid The unique identifier for the received LayerZero message.
     * @param _message The payload of the received message.
     * @param _executor The address of the executor for the received message.
     * @param _extraData Additional arbitrary data provided by the corresponding executor.
     *
     * @dev Entry point for receiving msg/packet from the LayerZero endpoint.
     */
    function lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) public payable virtual {
        // Ensures that only the endpoint can attempt to lzReceive() messages to this OApp.
        if (address(endpoint) != msg.sender) revert OnlyEndpoint(msg.sender);

        // Ensure that the sender matches the expected peer for the source endpoint.
        if (_getPeerOrRevert(_origin.srcEid) != _origin.sender) revert OnlyPeer(_origin.srcEid, _origin.sender);

        // Call the internal OApp implementation of lzReceive.
        _lzReceive(_origin, _guid, _message, _executor, _extraData);
    }

    /**
     * @dev Internal function to implement lzReceive logic without needing to copy the basic parameter validation.
     */
    function _lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) internal virtual;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IOAppCore, ILayerZeroEndpointV2 } from "./interfaces/IOAppCore.sol";

/**
 * @title OAppCore
 * @dev Abstract contract implementing the IOAppCore interface with basic OApp configurations.
 */
abstract contract OAppCore is IOAppCore, Ownable {
    // The LayerZero endpoint associated with the given OApp
    ILayerZeroEndpointV2 public immutable endpoint;

    // Mapping to store peers associated with corresponding endpoints
    mapping(uint32 eid => bytes32 peer) public peers;

    /**
     * @dev Constructor to initialize the OAppCore with the provided endpoint and delegate.
     * @param _endpoint The address of the LOCAL Layer Zero endpoint.
     * @param _delegate The delegate capable of making OApp configurations inside of the endpoint.
     *
     * @dev The delegate typically should be set as the owner of the contract.
     */
    constructor(address _endpoint, address _delegate) {
        endpoint = ILayerZeroEndpointV2(_endpoint);

        if (_delegate == address(0)) revert InvalidDelegate();
        endpoint.setDelegate(_delegate);
    }

    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     *
     * @dev Only the owner/admin of the OApp can call this function.
     * @dev Indicates that the peer is trusted to send LayerZero messages to this OApp.
     * @dev Set this to bytes32(0) to remove the peer address.
     * @dev Peer is a bytes32 to accommodate non-evm chains.
     */
    function setPeer(uint32 _eid, bytes32 _peer) public virtual onlyOwner {
        _setPeer(_eid, _peer);
    }

    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     *
     * @dev Indicates that the peer is trusted to send LayerZero messages to this OApp.
     * @dev Set this to bytes32(0) to remove the peer address.
     * @dev Peer is a bytes32 to accommodate non-evm chains.
     */
    function _setPeer(uint32 _eid, bytes32 _peer) internal virtual {
        peers[_eid] = _peer;
        emit PeerSet(_eid, _peer);
    }

    /**
     * @notice Internal function to get the peer address associated with a specific endpoint; reverts if NOT set.
     * ie. the peer is set to bytes32(0).
     * @param _eid The endpoint ID.
     * @return peer The address of the peer associated with the specified endpoint.
     */
    function _getPeerOrRevert(uint32 _eid) internal view virtual returns (bytes32) {
        bytes32 peer = peers[_eid];
        if (peer == bytes32(0)) revert NoPeer(_eid);
        return peer;
    }

    /**
     * @notice Sets the delegate address for the OApp.
     * @param _delegate The address of the delegate to be set.
     *
     * @dev Only the owner/admin of the OApp can call this function.
     * @dev Provides the ability for a delegate to set configs, on behalf of the OApp, directly on the Endpoint contract.
     */
    function setDelegate(address _delegate) public onlyOwner {
        endpoint.setDelegate(_delegate);
    }
}

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

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
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 v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: Unlicense
/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <[email protected]>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */
pragma solidity >=0.8.0 <0.9.0;


library BytesLib {
    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))

                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_length + 31 >= _length, "slice_overflow");
        require(_bytes.length >= _start + _length, "slice_outOfBounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
        require(_bytes.length >= _start + 1 , "toUint8_outOfBounds");
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint256(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equal_nonAligned(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let endMinusWord := add(_preBytes, length)
                let mc := add(_preBytes, 0x20)
                let cc := add(_postBytes, 0x20)

                for {
                // the next line is the loop condition:
                // while(uint256(mc < endWord) + cb == 2)
                } eq(add(lt(mc, endMinusWord), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }

                // Only if still successful
                // For <1 word tail bytes
                if gt(success, 0) {
                    // Get the remainder of length/32
                    // length % 32 = AND(length, 32 - 1)
                    let numTailBytes := and(length, 0x1f)
                    let mcRem := mload(mc)
                    let ccRem := mload(cc)
                    for {
                        let i := 0
                    // the next line is the loop condition:
                    // while(uint256(i < numTailBytes) + cb == 2)
                    } eq(add(lt(i, numTailBytes), cb), 2) {
                        i := add(i, 1)
                    } {
                        if iszero(eq(byte(i, mcRem), byte(i, ccRem))) {
                            // unsuccess:
                            success := 0
                            cb := 0
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    )
        internal
        view
        returns (bool)
    {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint256(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

pragma solidity ^0.8.20;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);

    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);

    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);

    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);

    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        if (value > type(uint184).max) {
            revert SafeCastOverflowedUintDowncast(184, value);
        }
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }
}

// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { CalldataBytesLib } from "../../libs/CalldataBytesLib.sol";

library ExecutorOptions {
    using CalldataBytesLib for bytes;

    uint8 internal constant WORKER_ID = 1;

    uint8 internal constant OPTION_TYPE_LZRECEIVE = 1;
    uint8 internal constant OPTION_TYPE_NATIVE_DROP = 2;
    uint8 internal constant OPTION_TYPE_LZCOMPOSE = 3;
    uint8 internal constant OPTION_TYPE_ORDERED_EXECUTION = 4;

    error Executor_InvalidLzReceiveOption();
    error Executor_InvalidNativeDropOption();
    error Executor_InvalidLzComposeOption();

    /// @dev decode the next executor option from the options starting from the specified cursor
    /// @param _options [executor_id][executor_option][executor_id][executor_option]...
    ///        executor_option = [option_size][option_type][option]
    ///        option_size = len(option_type) + len(option)
    ///        executor_id: uint8, option_size: uint16, option_type: uint8, option: bytes
    /// @param _cursor the cursor to start decoding from
    /// @return optionType the type of the option
    /// @return option the option of the executor
    /// @return cursor the cursor to start decoding the next executor option
    function nextExecutorOption(
        bytes calldata _options,
        uint256 _cursor
    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
        unchecked {
            // skip worker id
            cursor = _cursor + 1;

            // read option size
            uint16 size = _options.toU16(cursor);
            cursor += 2;

            // read option type
            optionType = _options.toU8(cursor);

            // startCursor and endCursor are used to slice the option from _options
            uint256 startCursor = cursor + 1; // skip option type
            uint256 endCursor = cursor + size;
            option = _options[startCursor:endCursor];
            cursor += size;
        }
    }

    function decodeLzReceiveOption(bytes calldata _option) internal pure returns (uint128 gas, uint128 value) {
        if (_option.length != 16 && _option.length != 32) revert Executor_InvalidLzReceiveOption();
        gas = _option.toU128(0);
        value = _option.length == 32 ? _option.toU128(16) : 0;
    }

    function decodeNativeDropOption(bytes calldata _option) internal pure returns (uint128 amount, bytes32 receiver) {
        if (_option.length != 48) revert Executor_InvalidNativeDropOption();
        amount = _option.toU128(0);
        receiver = _option.toB32(16);
    }

    function decodeLzComposeOption(
        bytes calldata _option
    ) internal pure returns (uint16 index, uint128 gas, uint128 value) {
        if (_option.length != 18 && _option.length != 34) revert Executor_InvalidLzComposeOption();
        index = _option.toU16(0);
        gas = _option.toU128(2);
        value = _option.length == 34 ? _option.toU128(18) : 0;
    }

    function encodeLzReceiveOption(uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
        return _value == 0 ? abi.encodePacked(_gas) : abi.encodePacked(_gas, _value);
    }

    function encodeNativeDropOption(uint128 _amount, bytes32 _receiver) internal pure returns (bytes memory) {
        return abi.encodePacked(_amount, _receiver);
    }

    function encodeLzComposeOption(uint16 _index, uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
        return _value == 0 ? abi.encodePacked(_index, _gas) : abi.encodePacked(_index, _gas, _value);
    }
}

// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

import { BytesLib } from "solidity-bytes-utils/contracts/BytesLib.sol";

import { BitMap256 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/BitMaps.sol";
import { CalldataBytesLib } from "@layerzerolabs/lz-evm-protocol-v2/contracts/libs/CalldataBytesLib.sol";

library DVNOptions {
    using CalldataBytesLib for bytes;
    using BytesLib for bytes;

    uint8 internal constant WORKER_ID = 2;
    uint8 internal constant OPTION_TYPE_PRECRIME = 1;

    error DVN_InvalidDVNIdx();
    error DVN_InvalidDVNOptions(uint256 cursor);

    /// @dev group dvn options by its idx
    /// @param _options [dvn_id][dvn_option][dvn_id][dvn_option]...
    ///        dvn_option = [option_size][dvn_idx][option_type][option]
    ///        option_size = len(dvn_idx) + len(option_type) + len(option)
    ///        dvn_id: uint8, dvn_idx: uint8, option_size: uint16, option_type: uint8, option: bytes
    /// @return dvnOptions the grouped options, still share the same format of _options
    /// @return dvnIndices the dvn indices
    function groupDVNOptionsByIdx(
        bytes memory _options
    ) internal pure returns (bytes[] memory dvnOptions, uint8[] memory dvnIndices) {
        if (_options.length == 0) return (dvnOptions, dvnIndices);

        uint8 numDVNs = getNumDVNs(_options);

        // if there is only 1 dvn, we can just return the whole options
        if (numDVNs == 1) {
            dvnOptions = new bytes[](1);
            dvnOptions[0] = _options;

            dvnIndices = new uint8[](1);
            dvnIndices[0] = _options.toUint8(3); // dvn idx
            return (dvnOptions, dvnIndices);
        }

        // otherwise, we need to group the options by dvn_idx
        dvnIndices = new uint8[](numDVNs);
        dvnOptions = new bytes[](numDVNs);
        unchecked {
            uint256 cursor = 0;
            uint256 start = 0;
            uint8 lastDVNIdx = 255; // 255 is an invalid dvn_idx

            while (cursor < _options.length) {
                ++cursor; // skip worker_id

                // optionLength asserted in getNumDVNs (skip check)
                uint16 optionLength = _options.toUint16(cursor);
                cursor += 2;

                // dvnIdx asserted in getNumDVNs (skip check)
                uint8 dvnIdx = _options.toUint8(cursor);

                // dvnIdx must equal to the lastDVNIdx for the first option
                // so it is always skipped in the first option
                // this operation slices out options whenever the scan finds a different lastDVNIdx
                if (lastDVNIdx == 255) {
                    lastDVNIdx = dvnIdx;
                } else if (dvnIdx != lastDVNIdx) {
                    uint256 len = cursor - start - 3; // 3 is for worker_id and option_length
                    bytes memory opt = _options.slice(start, len);
                    _insertDVNOptions(dvnOptions, dvnIndices, lastDVNIdx, opt);

                    // reset the start and lastDVNIdx
                    start += len;
                    lastDVNIdx = dvnIdx;
                }

                cursor += optionLength;
            }

            // skip check the cursor here because the cursor is asserted in getNumDVNs
            // if we have reached the end of the options, we need to process the last dvn
            uint256 size = cursor - start;
            bytes memory op = _options.slice(start, size);
            _insertDVNOptions(dvnOptions, dvnIndices, lastDVNIdx, op);

            // revert dvnIndices to start from 0
            for (uint8 i = 0; i < numDVNs; ++i) {
                --dvnIndices[i];
            }
        }
    }

    function _insertDVNOptions(
        bytes[] memory _dvnOptions,
        uint8[] memory _dvnIndices,
        uint8 _dvnIdx,
        bytes memory _newOptions
    ) internal pure {
        // dvnIdx starts from 0 but default value of dvnIndices is 0,
        // so we tell if the slot is empty by adding 1 to dvnIdx
        if (_dvnIdx == 255) revert DVN_InvalidDVNIdx();
        uint8 dvnIdxAdj = _dvnIdx + 1;

        for (uint256 j = 0; j < _dvnIndices.length; ++j) {
            uint8 index = _dvnIndices[j];
            if (dvnIdxAdj == index) {
                _dvnOptions[j] = abi.encodePacked(_dvnOptions[j], _newOptions);
                break;
            } else if (index == 0) {
                // empty slot, that means it is the first time we see this dvn
                _dvnIndices[j] = dvnIdxAdj;
                _dvnOptions[j] = _newOptions;
                break;
            }
        }
    }

    /// @dev get the number of unique dvns
    /// @param _options the format is the same as groupDVNOptionsByIdx
    function getNumDVNs(bytes memory _options) internal pure returns (uint8 numDVNs) {
        uint256 cursor = 0;
        BitMap256 bitmap;

        // find number of unique dvn_idx
        unchecked {
            while (cursor < _options.length) {
                ++cursor; // skip worker_id

                uint16 optionLength = _options.toUint16(cursor);
                cursor += 2;
                if (optionLength < 2) revert DVN_InvalidDVNOptions(cursor); // at least 1 byte for dvn_idx and 1 byte for option_type

                uint8 dvnIdx = _options.toUint8(cursor);

                // if dvnIdx is not set, increment numDVNs
                // max num of dvns is 255, 255 is an invalid dvn_idx
                // The order of the dvnIdx is not required to be sequential, as enforcing the order may weaken
                // the composability of the options. e.g. if we refrain from enforcing the order, an OApp that has
                // already enforced certain options can append additional options to the end of the enforced
                // ones without restrictions.
                if (dvnIdx == 255) revert DVN_InvalidDVNIdx();
                if (!bitmap.get(dvnIdx)) {
                    ++numDVNs;
                    bitmap = bitmap.set(dvnIdx);
                }

                cursor += optionLength;
            }
        }
        if (cursor != _options.length) revert DVN_InvalidDVNOptions(cursor);
    }

    /// @dev decode the next dvn option from _options starting from the specified cursor
    /// @param _options the format is the same as groupDVNOptionsByIdx
    /// @param _cursor the cursor to start decoding
    /// @return optionType the type of the option
    /// @return option the option
    /// @return cursor the cursor to start decoding the next option
    function nextDVNOption(
        bytes calldata _options,
        uint256 _cursor
    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
        unchecked {
            // skip worker id
            cursor = _cursor + 1;

            // read option size
            uint16 size = _options.toU16(cursor);
            cursor += 2;

            // read option type
            optionType = _options.toU8(cursor + 1); // skip dvn_idx

            // startCursor and endCursor are used to slice the option from _options
            uint256 startCursor = cursor + 2; // skip option type and dvn_idx
            uint256 endCursor = cursor + size;
            option = _options[startCursor:endCursor];
            cursor += size;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

import { IMessageLibManager } from "./IMessageLibManager.sol";
import { IMessagingComposer } from "./IMessagingComposer.sol";
import { IMessagingChannel } from "./IMessagingChannel.sol";
import { IMessagingContext } from "./IMessagingContext.sol";

struct MessagingParams {
    uint32 dstEid;
    bytes32 receiver;
    bytes message;
    bytes options;
    bool payInLzToken;
}

struct MessagingReceipt {
    bytes32 guid;
    uint64 nonce;
    MessagingFee fee;
}

struct MessagingFee {
    uint256 nativeFee;
    uint256 lzTokenFee;
}

struct Origin {
    uint32 srcEid;
    bytes32 sender;
    uint64 nonce;
}

interface ILayerZeroEndpointV2 is IMessageLibManager, IMessagingComposer, IMessagingChannel, IMessagingContext {
    event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);

    event PacketVerified(Origin origin, address receiver, bytes32 payloadHash);

    event PacketDelivered(Origin origin, address receiver);

    event LzReceiveAlert(
        address indexed receiver,
        address indexed executor,
        Origin origin,
        bytes32 guid,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );

    event LzTokenSet(address token);

    event DelegateSet(address sender, address delegate);

    function quote(MessagingParams calldata _params, address _sender) external view returns (MessagingFee memory);

    function send(
        MessagingParams calldata _params,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory);

    function verify(Origin calldata _origin, address _receiver, bytes32 _payloadHash) external;

    function verifiable(Origin calldata _origin, address _receiver) external view returns (bool);

    function initializable(Origin calldata _origin, address _receiver) external view returns (bool);

    function lzReceive(
        Origin calldata _origin,
        address _receiver,
        bytes32 _guid,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;

    // oapp can burn messages partially by calling this function with its own business logic if messages are verified in order
    function clear(address _oapp, Origin calldata _origin, bytes32 _guid, bytes calldata _message) external;

    function setLzToken(address _lzToken) external;

    function lzToken() external view returns (address);

    function nativeToken() external view returns (address);

    function setDelegate(address _delegate) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import { ILayerZeroReceiver, Origin } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroReceiver.sol";

interface IOAppReceiver is ILayerZeroReceiver {
    /**
     * @notice Indicates whether an address is an approved composeMsg sender to the Endpoint.
     * @param _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @param _message The lzReceive payload.
     * @param _sender The sender address.
     * @return isSender Is a valid sender.
     *
     * @dev Applications can optionally choose to implement a separate composeMsg sender that is NOT the bridging layer.
     * @dev The default sender IS the OAppReceiver implementer.
     */
    function isComposeMsgSender(
        Origin calldata _origin,
        bytes calldata _message,
        address _sender
    ) external view returns (bool isSender);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { ILayerZeroEndpointV2 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";

/**
 * @title IOAppCore
 */
interface IOAppCore {
    // Custom error messages
    error OnlyPeer(uint32 eid, bytes32 sender);
    error NoPeer(uint32 eid);
    error InvalidEndpointCall();
    error InvalidDelegate();

    // Event emitted when a peer (OApp) is set for a corresponding endpoint
    event PeerSet(uint32 eid, bytes32 peer);

    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     */
    function oAppVersion() external view returns (uint64 senderVersion, uint64 receiverVersion);

    /**
     * @notice Retrieves the LayerZero endpoint associated with the OApp.
     * @return iEndpoint The LayerZero endpoint as an interface.
     */
    function endpoint() external view returns (ILayerZeroEndpointV2 iEndpoint);

    /**
     * @notice Retrieves the peer (OApp) associated with a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @return peer The peer address (OApp instance) associated with the corresponding endpoint.
     */
    function peers(uint32 _eid) external view returns (bytes32 peer);

    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     */
    function setPeer(uint32 _eid, bytes32 _peer) external;

    /**
     * @notice Sets the delegate address for the OApp Core.
     * @param _delegate The address of the delegate to be set.
     */
    function setDelegate(address _delegate) external;
}

// SPDX-License-Identifier: LZBL-1.2

pragma solidity ^0.8.20;

library CalldataBytesLib {
    function toU8(bytes calldata _bytes, uint256 _start) internal pure returns (uint8) {
        return uint8(_bytes[_start]);
    }

    function toU16(bytes calldata _bytes, uint256 _start) internal pure returns (uint16) {
        unchecked {
            uint256 end = _start + 2;
            return uint16(bytes2(_bytes[_start:end]));
        }
    }

    function toU32(bytes calldata _bytes, uint256 _start) internal pure returns (uint32) {
        unchecked {
            uint256 end = _start + 4;
            return uint32(bytes4(_bytes[_start:end]));
        }
    }

    function toU64(bytes calldata _bytes, uint256 _start) internal pure returns (uint64) {
        unchecked {
            uint256 end = _start + 8;
            return uint64(bytes8(_bytes[_start:end]));
        }
    }

    function toU128(bytes calldata _bytes, uint256 _start) internal pure returns (uint128) {
        unchecked {
            uint256 end = _start + 16;
            return uint128(bytes16(_bytes[_start:end]));
        }
    }

    function toU256(bytes calldata _bytes, uint256 _start) internal pure returns (uint256) {
        unchecked {
            uint256 end = _start + 32;
            return uint256(bytes32(_bytes[_start:end]));
        }
    }

    function toAddr(bytes calldata _bytes, uint256 _start) internal pure returns (address) {
        unchecked {
            uint256 end = _start + 20;
            return address(bytes20(_bytes[_start:end]));
        }
    }

    function toB32(bytes calldata _bytes, uint256 _start) internal pure returns (bytes32) {
        unchecked {
            uint256 end = _start + 32;
            return bytes32(_bytes[_start:end]);
        }
    }
}

// SPDX-License-Identifier: MIT

// modified from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/structs/BitMaps.sol
pragma solidity ^0.8.20;

type BitMap256 is uint256;

using BitMaps for BitMap256 global;

library BitMaps {
    /**
     * @dev Returns whether the bit at `index` is set.
     */
    function get(BitMap256 bitmap, uint8 index) internal pure returns (bool) {
        uint256 mask = 1 << index;
        return BitMap256.unwrap(bitmap) & mask != 0;
    }

    /**
     * @dev Sets the bit at `index`.
     */
    function set(BitMap256 bitmap, uint8 index) internal pure returns (BitMap256) {
        uint256 mask = 1 << index;
        return BitMap256.wrap(BitMap256.unwrap(bitmap) | mask);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

struct SetConfigParam {
    uint32 eid;
    uint32 configType;
    bytes config;
}

interface IMessageLibManager {
    struct Timeout {
        address lib;
        uint256 expiry;
    }

    event LibraryRegistered(address newLib);
    event DefaultSendLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibraryTimeoutSet(uint32 eid, address oldLib, uint256 expiry);
    event SendLibrarySet(address sender, uint32 eid, address newLib);
    event ReceiveLibrarySet(address receiver, uint32 eid, address newLib);
    event ReceiveLibraryTimeoutSet(address receiver, uint32 eid, address oldLib, uint256 timeout);

    function registerLibrary(address _lib) external;

    function isRegisteredLibrary(address _lib) external view returns (bool);

    function getRegisteredLibraries() external view returns (address[] memory);

    function setDefaultSendLibrary(uint32 _eid, address _newLib) external;

    function defaultSendLibrary(uint32 _eid) external view returns (address);

    function setDefaultReceiveLibrary(uint32 _eid, address _newLib, uint256 _timeout) external;

    function defaultReceiveLibrary(uint32 _eid) external view returns (address);

    function setDefaultReceiveLibraryTimeout(uint32 _eid, address _lib, uint256 _expiry) external;

    function defaultReceiveLibraryTimeout(uint32 _eid) external view returns (address lib, uint256 expiry);

    function isSupportedEid(uint32 _eid) external view returns (bool);

    function isValidReceiveLibrary(address _receiver, uint32 _eid, address _lib) external view returns (bool);

    /// ------------------- OApp interfaces -------------------
    function setSendLibrary(address _oapp, uint32 _eid, address _newLib) external;

    function getSendLibrary(address _sender, uint32 _eid) external view returns (address lib);

    function isDefaultSendLibrary(address _sender, uint32 _eid) external view returns (bool);

    function setReceiveLibrary(address _oapp, uint32 _eid, address _newLib, uint256 _gracePeriod) external;

    function getReceiveLibrary(address _receiver, uint32 _eid) external view returns (address lib, bool isDefault);

    function setReceiveLibraryTimeout(address _oapp, uint32 _eid, address _lib, uint256 _gracePeriod) external;

    function receiveLibraryTimeout(address _receiver, uint32 _eid) external view returns (address lib, uint256 expiry);

    function setConfig(address _oapp, address _lib, SetConfigParam[] calldata _params) external;

    function getConfig(
        address _oapp,
        address _lib,
        uint32 _eid,
        uint32 _configType
    ) external view returns (bytes memory config);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingComposer {
    event ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message);
    event ComposeDelivered(address from, address to, bytes32 guid, uint16 index);
    event LzComposeAlert(
        address indexed from,
        address indexed to,
        address indexed executor,
        bytes32 guid,
        uint16 index,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );

    function composeQueue(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index
    ) external view returns (bytes32 messageHash);

    function sendCompose(address _to, bytes32 _guid, uint16 _index, bytes calldata _message) external;

    function lzCompose(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingChannel {
    event InboundNonceSkipped(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce);
    event PacketNilified(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);
    event PacketBurnt(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);

    function eid() external view returns (uint32);

    // this is an emergency function if a message cannot be verified for some reasons
    // required to provide _nextNonce to avoid race condition
    function skip(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce) external;

    function nilify(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

    function burn(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

    function nextGuid(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (bytes32);

    function inboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);

    function outboundNonce(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (uint64);

    function inboundPayloadHash(
        address _receiver,
        uint32 _srcEid,
        bytes32 _sender,
        uint64 _nonce
    ) external view returns (bytes32);

    function lazyInboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingContext {
    function isSendingMessage() external view returns (bool);

    function getSendContext() external view returns (uint32 dstEid, address sender);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

import { Origin } from "./ILayerZeroEndpointV2.sol";

interface ILayerZeroReceiver {
    function allowInitializePath(Origin calldata _origin) external view returns (bool);

    function nextNonce(uint32 _eid, bytes32 _sender) external view returns (uint64);

    function lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external payable;
}

{
  "remappings": [
    "src/=src/",
    "ds-test/=node_modules/@layerzerolabs/toolbox-foundry/lib/ds-test/",
    "forge-std/=node_modules/@layerzerolabs/toolbox-foundry/lib/forge-std/src/",
    "@layerzerolabs/=node_modules/@layerzerolabs/",
    "@openzeppelin/=node_modules/@openzeppelin/",
    "heroglyph-library/=node_modules/@layerzerolabs/toolbox-foundry/lib/heroglyph-library/src/",
    "@axelar-network/=node_modules/@axelar-network/",
    "@chainlink/=node_modules/@chainlink/",
    "@eth-optimism/=node_modules/@eth-optimism/",
    "hardhat-deploy/=node_modules/hardhat-deploy/",
    "hardhat/=node_modules/hardhat/",
    "solidity-bytes-utils/=node_modules/solidity-bytes-utils/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint32","name":"crossChainFee","type":"uint32"},{"internalType":"uint256","name":"preMintAmount","type":"uint256"},{"internalType":"address","name":"genesisHub","type":"address"},{"components":[{"internalType":"uint256","name":"fixedRate","type":"uint256"},{"internalType":"uint256","name":"maxBonusFullDay","type":"uint256"}],"internalType":"struct IGenesisToken.GenesisConfiguration","name":"configuration","type":"tuple"}],"internalType":"struct IGenesisToken.GenesisConstructor","name":"_args","type":"tuple"},{"components":[{"internalType":"address","name":"wrappedNative","type":"address"},{"internalType":"address","name":"key","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"treasury","type":"address"},{"internalType":"address","name":"feePayer","type":"address"},{"internalType":"address","name":"heroglyphRelay","type":"address"},{"internalType":"address","name":"localLzEndpoint","type":"address"},{"internalType":"uint32","name":"localLzEndpointID","type":"uint32"},{"internalType":"uint32","name":"lzGasLimit","type":"uint32"},{"internalType":"uint256","name":"maxSupply","type":"uint256"}],"internalType":"struct IHeroOFTXOperator.HeroOFTXOperatorArgs","name":"_heroArgs","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"ConversionOutOfBounds","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"EmptyFeeCollector","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"FailedToSendETH","type":"error"},{"inputs":[],"name":"FailedToSendWETH","type":"error"},{"inputs":[],"name":"FeePayerCannotBeZero","type":"error"},{"inputs":[],"name":"FeeTooHigh","type":"error"},{"inputs":[],"name":"GasLimitCannotBeZero","type":"error"},{"inputs":[],"name":"InvalidDelegate","type":"error"},{"inputs":[],"name":"InvalidEndpointCall","type":"error"},{"inputs":[],"name":"InvalidLocalDecimals","type":"error"},{"inputs":[{"internalType":"uint16","name":"optionType","type":"uint16"}],"name":"InvalidOptionType","type":"error"},{"inputs":[],"name":"LzTokenUnavailable","type":"error"},{"inputs":[],"name":"MathOverflowedMulDiv","type":"error"},{"inputs":[],"name":"NoAction","type":"error"},{"inputs":[],"name":"NoKeyDetected","type":"error"},{"inputs":[{"internalType":"uint32","name":"eid","type":"uint32"}],"name":"NoPeer","type":"error"},{"inputs":[],"name":"NoPermission","type":"error"},{"inputs":[],"name":"NoRedeemTokenDectected","type":"error"},{"inputs":[],"name":"NoRewardCurrently","type":"error"},{"inputs":[{"internalType":"uint256","name":"msgValue","type":"uint256"}],"name":"NotEnoughNative","type":"error"},{"inputs":[],"name":"NotEnoughToLayerZeroFee","type":"error"},{"inputs":[],"name":"NotHeroglyph","type":"error"},{"inputs":[],"name":"NotgenesisHub","type":"error"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"OnlyEndpoint","type":"error"},{"inputs":[{"internalType":"uint32","name":"eid","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"}],"name":"OnlyPeer","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"RedeemDecayTooHigh","type":"error"},{"inputs":[],"name":"RewardLowerThanMinimumAllowed","type":"error"},{"inputs":[{"internalType":"uint8","name":"bits","type":"uint8"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"SafeCastOverflowedUintDowncast","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"uint256","name":"amountLD","type":"uint256"},{"internalType":"uint256","name":"minAmountLD","type":"uint256"}],"name":"SlippageExceeded","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"fixedRate","type":"uint256"},{"internalType":"uint256","name":"maxBonusFullDay","type":"uint256"}],"indexed":false,"internalType":"struct IGenesisToken.GenesisConfiguration","name":"configuration","type":"tuple"}],"name":"ConfigurationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"feePayer","type":"address"}],"name":"FeePayerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"relay","type":"address"}],"name":"HeroglyphRelayUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"guid","type":"bytes32"},{"indexed":true,"internalType":"uint32","name":"sourceEndpointId","type":"uint32"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountOrId","type":"uint256"}],"name":"OFTReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"guid","type":"bytes32"},{"indexed":true,"internalType":"uint32","name":"destinationEndpointId","type":"uint32"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountOrId","type":"uint256"}],"name":"OFTSent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountOrNftId","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"errorMessage","type":"bytes"}],"name":"OnCrossChainCallFails","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"eid","type":"uint32"},{"indexed":false,"internalType":"bytes32","name":"peer","type":"bytes32"}],"name":"PeerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"TokenRedeemed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"treasury","type":"address"}],"name":"TreasuryUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"genesisHub","type":"address"}],"name":"genesisHubUpdated","type":"event"},{"inputs":[],"name":"ERROR_LZ_RETURNED_FALSE","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_BPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SECOND_PER_BLOCK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"srcEid","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"}],"internalType":"struct Origin","name":"origin","type":"tuple"}],"name":"allowInitializePath","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_srcLzEndpoint","type":"uint32"},{"internalType":"uint256[]","name":"_indexes","type":"uint256[]"}],"name":"claimAction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"crossChainFee","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimalConversionRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultLzOption","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endpoint","outputs":[{"internalType":"contract ILayerZeroEndpointV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_dstEid","type":"uint32"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"estimateFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeCollector","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_srcLzEndpoint","type":"uint32"},{"internalType":"address","name":"_of","type":"address"},{"internalType":"uint256[]","name":"_indexes","type":"uint256[]"}],"name":"forgiveDebt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"genesisHub","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_srcLzEndpoint","type":"uint32"},{"internalType":"address","name":"_of","type":"address"},{"internalType":"uint256[]","name":"_indexes","type":"uint256[]"}],"name":"getActionsFeeTotal","outputs":[{"internalType":"uint256","name":"amountDue_","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getConfiguration","outputs":[{"components":[{"internalType":"uint256","name":"fixedRate","type":"uint256"},{"internalType":"uint256","name":"maxBonusFullDay","type":"uint256"}],"internalType":"struct IGenesisToken.GenesisConfiguration","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFeePayer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLatestBlockMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_multiplier","type":"uint256"}],"name":"getNextReward","outputs":[{"internalType":"uint256","name":"redeemReward_","type":"uint256"},{"internalType":"uint256","name":"blockProducingReward_","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"_lzEndpointID","type":"uint32"},{"internalType":"address","name":"_user","type":"address"}],"name":"getPendingActions","outputs":[{"components":[{"internalType":"uint256","name":"amountOrId","type":"uint256"},{"internalType":"uint128","name":"fee","type":"uint128"}],"internalType":"struct IHeroOFTXOperator.RequireAction[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"heroglyphRelay","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"srcEid","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"}],"internalType":"struct Origin","name":"","type":"tuple"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"address","name":"_sender","type":"address"}],"name":"isComposeMsgSender","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"key","outputs":[{"internalType":"contract IKey","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastMintTriggered","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"localLzEndpointID","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lzGasLimit","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"srcEid","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"}],"internalType":"struct Origin","name":"_origin","type":"tuple"},{"internalType":"bytes32","name":"_guid","type":"bytes32"},{"internalType":"bytes","name":"_message","type":"bytes"},{"internalType":"address","name":"_executor","type":"address"},{"internalType":"bytes","name":"_extraData","type":"bytes"}],"name":"lzReceive","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"","type":"uint32"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"nextNonce","outputs":[{"internalType":"uint64","name":"nonce","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oAppVersion","outputs":[{"internalType":"uint64","name":"senderVersion","type":"uint64"},{"internalType":"uint64","name":"receiverVersion","type":"uint64"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint32","name":"_lzEndpointSelected","type":"uint32"},{"internalType":"uint32","name":"_blockMinted","type":"uint32"},{"internalType":"address","name":"_validatorWithdrawer","type":"address"},{"internalType":"uint128","name":"_feeToRepay","type":"uint128"}],"name":"onValidatorTriggered","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"eid","type":"uint32"}],"name":"peers","outputs":[{"internalType":"bytes32","name":"peer","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_multiplier","type":"uint256"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"rewardMinted_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"retrieveNative","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_dstEid","type":"uint32"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"uint256","name":"_minAmountOut","type":"uint256"}],"name":"send","outputs":[{"components":[{"internalType":"bytes32","name":"guid","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"},{"components":[{"internalType":"uint256","name":"nativeFee","type":"uint256"},{"internalType":"uint256","name":"lzTokenFee","type":"uint256"}],"internalType":"struct MessagingFee","name":"fee","type":"tuple"}],"internalType":"struct MessagingReceipt","name":"msgReceipt","type":"tuple"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_delegate","type":"address"}],"name":"setDelegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_eid","type":"uint32"},{"internalType":"bytes32","name":"_peer","type":"bytes32"}],"name":"setPeer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sharedDecimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalMintedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"fixedRate","type":"uint256"},{"internalType":"uint256","name":"maxBonusFullDay","type":"uint256"}],"internalType":"struct IGenesisToken.GenesisConfiguration","name":"_configuration","type":"tuple"}],"name":"updateConfiguration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_fee","type":"uint32"}],"name":"updateCrossChainFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeCollector","type":"address"}],"name":"updateFeeCollector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feePayer","type":"address"}],"name":"updateFeePayer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_genesisHub","type":"address"}],"name":"updateGenesisHub","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_relay","type":"address"}],"name":"updateHeroglyphRelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_lzGasLimit","type":"uint32"}],"name":"updateLayerZeroGasLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_wrapper","type":"address"}],"name":"updateNativeWrapper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"updateTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_lzDstEndpointId","type":"uint32"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"validatorLZSend","outputs":[{"internalType":"bool","name":"success_","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wrappedNative","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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