Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import {IUniswapV2Pair} from "./interfaces/external/IUniswapV2Pair.sol";
import {IWomo} from "./interfaces/external/IWomo.sol";
import {IStaking} from "./interfaces/external/IStaking.sol";
import {IOwnable} from "./interfaces/external/IOwnable.sol";
import {LowGasSafeMath} from "./libs/LowGasSafeMath.sol";

import "@openzeppelin/contracts/access/Ownable.sol";
import "abdk-libraries-solidity/ABDKMath64x64.sol";

contract Rebaser is Ownable {
    using LowGasSafeMath for uint256;
    using LowGasSafeMath for uint32;

    uint256 public constant BPS = 10000;
    uint256 public immutable FRACTION_FACTOR;
    uint256 public finalSupply;

    IWomo public immutable womo;
    IUniswapV2Pair[] public syncPairs;
    uint256 public compoundRatio; // Compound ratio which for example 1e18 is 100% (will be used to decrease supply)
    // Start rebase from startTime
    uint256 public lastTime;
    uint256 deflationCompensationPercentage;
    mapping(address => bool) public approvedCallers;

    bool public useAutoStakingAdjustment = true;
    bool public computedOnTheFly = true;
    uint256 public rebaseCount;

    // Info for incremental adjustments to control variable
    struct Adjust {
        bool add; // addition or subtraction
        uint rate; // increment
        uint target; // CR when adjustment finished
        uint32 buffer; // minimum length (in seconds) between adjustments
        uint32 lastTime; // time when last adjustment made
    }

    IStaking stakingS;
    IStaking stakingUSDC;

    Adjust public adjustment; // stores adjustment to CR data

    modifier onlyApprovedCallers() {
        require(approvedCallers[msg.sender], "Rebaser: rebaser not approved");
        _;
    }

    event CompoundRatioAdjustment(
        uint initialBCV,
        uint newBCV,
        uint adjustment,
        bool addition
    );

    constructor(
        IWomo _womo,
        uint256 _compoundRatio,
        uint256 _startTime,
        uint256 _deflationCompensationPercentage,
        uint256 _fractionFactor,
        uint256 _rebaseDuration
    ) {
        womo = _womo;
        compoundRatio = _compoundRatio;
        lastTime = block.timestamp > _startTime ? block.timestamp : _startTime;
        deflationCompensationPercentage = _deflationCompensationPercentage;
        FRACTION_FACTOR = _fractionFactor;
        rebaseCount = _rebaseDuration / _fractionFactor;
    }

    function rebase() external onlyApprovedCallers {
        if (
            lastTime + FRACTION_FACTOR <= block.timestamp &&
            womo.totalSupply() < finalSupply
        ) {
            stakingS.updateRewardPerInterval(0); //Emission ended
            stakingUSDC.updateRewardPerInterval(0); //Emission ended
            for (uint i = 0; i < syncPairs.length; i++) {
                syncPairs[i].sync();
            }
            lastTime = block.timestamp;
            return;
        }
        if (lastTime + FRACTION_FACTOR <= block.timestamp) {
            uint diff = (block.timestamp - lastTime) / FRACTION_FACTOR;
            uint prevSupply = womo.totalSupply();
            if (computedOnTheFly) {
                if (rebaseCount > 0) {
                    if (diff > rebaseCount) {
                        diff = rebaseCount;
                    }
                    compoundRatio = _calculateDynamicCompoundRatio();
                    womo.rebase(
                        block.timestamp,
                        compound(1e18, compoundRatio, diff) - 1e18,
                        false
                    );
                    rebaseCount -= diff;
                } else {
                    return;
                }
            } else {
                womo.rebase(
                    block.timestamp,
                    compound(1e18, compoundRatio, diff) - 1e18,
                    false
                );
            }

            lastTime = block.timestamp;
            for (uint i = 0; i < syncPairs.length; i++) {
                syncPairs[i].sync();
            }
            if (useAutoStakingAdjustment) {
                uint rewardPerInterval = (((prevSupply - womo.totalSupply()) *
                    deflationCompensationPercentage) / BPS) / diff;
                stakingS.updateRewardPerInterval(rewardPerInterval / 2); //50 % for this pool
                stakingUSDC.updateRewardPerInterval(rewardPerInterval / 2); //50% for this pool. If there's a third pool, we'll divide it equally between the three
            }

            adjust(); // compoundRatio is adjusted
        }
    }

    function compound(
        uint256 principal,
        uint256 ratio,
        uint256 n
    ) public pure returns (uint256) {
        return
            ABDKMath64x64.mulu(
                ABDKMath64x64.pow(
                    ABDKMath64x64.add(
                        ABDKMath64x64.fromUInt(1),
                        ABDKMath64x64.divu(ratio, 10 ** 18)
                    ),
                    n
                ),
                principal
            );
    }

    function approveCaller(address _operator) external onlyOwner {
        approvedCallers[_operator] = true;
    }

    function disableCaller(address _operator) external onlyOwner {
        approvedCallers[_operator] = false;
    }

    function setStakingS(IStaking _staking) external onlyOwner {
        require(address(_staking) != address(0), "SNA");
        stakingS = _staking;
    }

    function setStakingUSDC(IStaking _staking) external onlyOwner {
        require(address(_staking) != address(0), "SNA");
        stakingUSDC = _staking;
    }

    function setCompensationPercentage(uint256 _percentage) external onlyOwner {
        require(_percentage <= BPS, "IP");
        deflationCompensationPercentage = _percentage;
    }

    function toogleAutoStakingAdjustmen() external onlyOwner {
        useAutoStakingAdjustment = !useAutoStakingAdjustment;
    }

    /**
     *  @notice set control variable adjustment
     *  @param _addition bool
     *  @param _increment uint
     *  @param _target uint
     *  @param _buffer uint
     */
    function setAdjustment(
        bool _addition,
        uint _increment,
        uint _target,
        uint32 _buffer
    ) external onlyOwner {
        adjustment = Adjust({
            add: _addition,
            rate: _increment,
            target: _target,
            buffer: _buffer,
            lastTime: uint32(block.timestamp)
        });
    }

    /**
     *  @notice set control variable to prevent stuck
     *  @param _compoundRatio bool
     */

    function setCompounRatio(uint _compoundRatio) external onlyOwner {
        compoundRatio = _compoundRatio;
    }

    function setFinalSupply(uint _finalSupply) external onlyOwner {
        finalSupply = _finalSupply;
    }

    function setFlyComputed(bool _computedOnTheFly) external onlyOwner {
        computedOnTheFly = _computedOnTheFly;
    }

    /**
     *  @notice makes incremental adjustment to control variable
     */
    function adjust() internal {
        uint timeCanAdjust = adjustment.lastTime.add32(adjustment.buffer);
        if (adjustment.rate != 0 && block.timestamp >= timeCanAdjust) {
            uint initial = compoundRatio;
            if (adjustment.add) {
                compoundRatio = compoundRatio.add(adjustment.rate);
                if (compoundRatio >= adjustment.target) {
                    adjustment.rate = 0;
                    compoundRatio = adjustment.target;
                }
            } else {
                compoundRatio = compoundRatio.sub(adjustment.rate);
                if (compoundRatio <= adjustment.target) {
                    adjustment.rate = 0;
                    compoundRatio = adjustment.target;
                }
            }
            adjustment.lastTime = uint32(block.timestamp);
            emit CompoundRatioAdjustment(
                initial,
                compoundRatio,
                adjustment.rate,
                adjustment.add
            );
        }
    }

    function _calculateDynamicCompoundRatio()
        internal
        view
        returns (uint256 _compoundRatio)
    {
        uint circulatingSupply = womo.totalSupply();
        require(circulatingSupply > finalSupply, "Already at or below target");
        require(rebaseCount > 0, "No rebases left");

        int128 logBase = ABDKMath64x64.ln(
            ABDKMath64x64.divu(finalSupply, circulatingSupply)
        );
        int128 logFraction = ABDKMath64x64.div(
            logBase,
            ABDKMath64x64.fromUInt(rebaseCount)
        );
        int128 decayFactor = ABDKMath64x64.exp(logFraction);

        int128 one = ABDKMath64x64.fromUInt(1);
        int128 ratio = ABDKMath64x64.sub(one, decayFactor);

        _compoundRatio = ABDKMath64x64.mulu(ratio, 1e18);
    }

    function changeRebaseDuration(uint _newDuration) external onlyOwner {
        rebaseCount = _newDuration / FRACTION_FACTOR;
    }

    function addSyncPair(address _pair) external onlyOwner {
        syncPairs.push(IUniswapV2Pair(_pair));
    }

    function removeSyncPair(address _pair) external onlyOwner {
        uint indexToRemove = type(uint).max;

        for (uint i = 0; i < syncPairs.length; i++) {
            if (address(syncPairs[i]) == _pair) {
                indexToRemove = i;
                break;
            }
        }

        if (indexToRemove < syncPairs.length) {
            syncPairs[indexToRemove] = syncPairs[syncPairs.length - 1];
            syncPairs.pop();
        }
    }
}

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

pragma solidity ^0.8.0;

import "../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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

// SPDX-License-Identifier: BSD-4-Clause
/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <[email protected]>
 */
pragma solidity ^0.8.0;

/**
 * Smart contract library of mathematical functions operating with signed
 * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
 * basically a simple fraction whose numerator is signed 128-bit integer and
 * denominator is 2^64.  As long as denominator is always the same, there is no
 * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
 * represented by int128 type holding only the numerator.
 */
library ABDKMath64x64 {
  /*
   * Minimum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;

  /*
   * Maximum value signed 64.64-bit fixed point number may have. 
   */
  int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;

  /**
   * Convert signed 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromInt (int256 x) internal pure returns (int128) {
    unchecked {
      require (x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
      return int128 (x << 64);
    }
  }

  /**
   * Convert signed 64.64 fixed point number into signed 64-bit integer number
   * rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64-bit integer number
   */
  function toInt (int128 x) internal pure returns (int64) {
    unchecked {
      return int64 (x >> 64);
    }
  }

  /**
   * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
   * number.  Revert on overflow.
   *
   * @param x unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function fromUInt (uint256 x) internal pure returns (int128) {
    unchecked {
      require (x <= 0x7FFFFFFFFFFFFFFF);
      return int128 (int256 (x << 64));
    }
  }

  /**
   * Convert signed 64.64 fixed point number into unsigned 64-bit integer
   * number rounding down.  Revert on underflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return unsigned 64-bit integer number
   */
  function toUInt (int128 x) internal pure returns (uint64) {
    unchecked {
      require (x >= 0);
      return uint64 (uint128 (x >> 64));
    }
  }

  /**
   * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
   * number rounding down.  Revert on overflow.
   *
   * @param x signed 128.128-bin fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function from128x128 (int256 x) internal pure returns (int128) {
    unchecked {
      int256 result = x >> 64;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Convert signed 64.64 fixed point number into signed 128.128 fixed point
   * number.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 128.128 fixed point number
   */
  function to128x128 (int128 x) internal pure returns (int256) {
    unchecked {
      return int256 (x) << 64;
    }
  }

  /**
   * Calculate x + y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function add (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) + y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x - y.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sub (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) - y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x * y rounding down.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function mul (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 result = int256(x) * y >> 64;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
   * number and y is signed 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y signed 256-bit integer number
   * @return signed 256-bit integer number
   */
  function muli (int128 x, int256 y) internal pure returns (int256) {
    unchecked {
      if (x == MIN_64x64) {
        require (y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
          y <= 0x1000000000000000000000000000000000000000000000000);
        return -y << 63;
      } else {
        bool negativeResult = false;
        if (x < 0) {
          x = -x;
          negativeResult = true;
        }
        if (y < 0) {
          y = -y; // We rely on overflow behavior here
          negativeResult = !negativeResult;
        }
        uint256 absoluteResult = mulu (x, uint256 (y));
        if (negativeResult) {
          require (absoluteResult <=
            0x8000000000000000000000000000000000000000000000000000000000000000);
          return -int256 (absoluteResult); // We rely on overflow behavior here
        } else {
          require (absoluteResult <=
            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
          return int256 (absoluteResult);
        }
      }
    }
  }

  /**
   * Calculate x * y rounding down, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64 fixed point number
   * @param y unsigned 256-bit integer number
   * @return unsigned 256-bit integer number
   */
  function mulu (int128 x, uint256 y) internal pure returns (uint256) {
    unchecked {
      if (y == 0) return 0;

      require (x >= 0);

      uint256 lo = (uint256 (int256 (x)) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
      uint256 hi = uint256 (int256 (x)) * (y >> 128);

      require (hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      hi <<= 64;

      require (hi <=
        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
      return hi + lo;
    }
  }

  /**
   * Calculate x / y rounding towards zero.  Revert on overflow or when y is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function div (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);
      int256 result = (int256 (x) << 64) / y;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are signed 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x signed 256-bit integer number
   * @param y signed 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divi (int256 x, int256 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);

      bool negativeResult = false;
      if (x < 0) {
        x = -x; // We rely on overflow behavior here
        negativeResult = true;
      }
      if (y < 0) {
        y = -y; // We rely on overflow behavior here
        negativeResult = !negativeResult;
      }
      uint128 absoluteResult = divuu (uint256 (x), uint256 (y));
      if (negativeResult) {
        require (absoluteResult <= 0x80000000000000000000000000000000);
        return -int128 (absoluteResult); // We rely on overflow behavior here
      } else {
        require (absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
        return int128 (absoluteResult); // We rely on overflow behavior here
      }
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return signed 64.64-bit fixed point number
   */
  function divu (uint256 x, uint256 y) internal pure returns (int128) {
    unchecked {
      require (y != 0);
      uint128 result = divuu (x, y);
      require (result <= uint128 (MAX_64x64));
      return int128 (result);
    }
  }

  /**
   * Calculate -x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function neg (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != MIN_64x64);
      return -x;
    }
  }

  /**
   * Calculate |x|.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function abs (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != MIN_64x64);
      return x < 0 ? -x : x;
    }
  }

  /**
   * Calculate 1 / x rounding towards zero.  Revert on overflow or when x is
   * zero.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function inv (int128 x) internal pure returns (int128) {
    unchecked {
      require (x != 0);
      int256 result = int256 (0x100000000000000000000000000000000) / x;
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function avg (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      return int128 ((int256 (x) + int256 (y)) >> 1);
    }
  }

  /**
   * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
   * Revert on overflow or in case x * y is negative.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function gavg (int128 x, int128 y) internal pure returns (int128) {
    unchecked {
      int256 m = int256 (x) * int256 (y);
      require (m >= 0);
      require (m <
          0x4000000000000000000000000000000000000000000000000000000000000000);
      return int128 (sqrtu (uint256 (m)));
    }
  }

  /**
   * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
   * and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @param y uint256 value
   * @return signed 64.64-bit fixed point number
   */
  function pow (int128 x, uint256 y) internal pure returns (int128) {
    unchecked {
      bool negative = x < 0 && y & 1 == 1;

      uint256 absX = uint128 (x < 0 ? -x : x);
      uint256 absResult;
      absResult = 0x100000000000000000000000000000000;

      if (absX <= 0x10000000000000000) {
        absX <<= 63;
        while (y != 0) {
          if (y & 0x1 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x2 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x4 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          if (y & 0x8 != 0) {
            absResult = absResult * absX >> 127;
          }
          absX = absX * absX >> 127;

          y >>= 4;
        }

        absResult >>= 64;
      } else {
        uint256 absXShift = 63;
        if (absX < 0x1000000000000000000000000) { absX <<= 32; absXShift -= 32; }
        if (absX < 0x10000000000000000000000000000) { absX <<= 16; absXShift -= 16; }
        if (absX < 0x1000000000000000000000000000000) { absX <<= 8; absXShift -= 8; }
        if (absX < 0x10000000000000000000000000000000) { absX <<= 4; absXShift -= 4; }
        if (absX < 0x40000000000000000000000000000000) { absX <<= 2; absXShift -= 2; }
        if (absX < 0x80000000000000000000000000000000) { absX <<= 1; absXShift -= 1; }

        uint256 resultShift = 0;
        while (y != 0) {
          require (absXShift < 64);

          if (y & 0x1 != 0) {
            absResult = absResult * absX >> 127;
            resultShift += absXShift;
            if (absResult > 0x100000000000000000000000000000000) {
              absResult >>= 1;
              resultShift += 1;
            }
          }
          absX = absX * absX >> 127;
          absXShift <<= 1;
          if (absX >= 0x100000000000000000000000000000000) {
              absX >>= 1;
              absXShift += 1;
          }

          y >>= 1;
        }

        require (resultShift < 64);
        absResult >>= 64 - resultShift;
      }
      int256 result = negative ? -int256 (absResult) : int256 (absResult);
      require (result >= MIN_64x64 && result <= MAX_64x64);
      return int128 (result);
    }
  }

  /**
   * Calculate sqrt (x) rounding down.  Revert if x < 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function sqrt (int128 x) internal pure returns (int128) {
    unchecked {
      require (x >= 0);
      return int128 (sqrtu (uint256 (int256 (x)) << 64));
    }
  }

  /**
   * Calculate binary logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function log_2 (int128 x) internal pure returns (int128) {
    unchecked {
      require (x > 0);

      int256 msb = 0;
      int256 xc = x;
      if (xc >= 0x10000000000000000) { xc >>= 64; msb += 64; }
      if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
      if (xc >= 0x10000) { xc >>= 16; msb += 16; }
      if (xc >= 0x100) { xc >>= 8; msb += 8; }
      if (xc >= 0x10) { xc >>= 4; msb += 4; }
      if (xc >= 0x4) { xc >>= 2; msb += 2; }
      if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

      int256 result = msb - 64 << 64;
      uint256 ux = uint256 (int256 (x)) << uint256 (127 - msb);
      for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
        ux *= ux;
        uint256 b = ux >> 255;
        ux >>= 127 + b;
        result += bit * int256 (b);
      }

      return int128 (result);
    }
  }

  /**
   * Calculate natural logarithm of x.  Revert if x <= 0.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function ln (int128 x) internal pure returns (int128) {
    unchecked {
      require (x > 0);

      return int128 (int256 (
          uint256 (int256 (log_2 (x))) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128));
    }
  }

  /**
   * Calculate binary exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp_2 (int128 x) internal pure returns (int128) {
    unchecked {
      require (x < 0x400000000000000000); // Overflow

      if (x < -0x400000000000000000) return 0; // Underflow

      uint256 result = 0x80000000000000000000000000000000;

      if (x & 0x8000000000000000 > 0)
        result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
      if (x & 0x4000000000000000 > 0)
        result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
      if (x & 0x2000000000000000 > 0)
        result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
      if (x & 0x1000000000000000 > 0)
        result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
      if (x & 0x800000000000000 > 0)
        result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
      if (x & 0x400000000000000 > 0)
        result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
      if (x & 0x200000000000000 > 0)
        result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
      if (x & 0x100000000000000 > 0)
        result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
      if (x & 0x80000000000000 > 0)
        result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
      if (x & 0x40000000000000 > 0)
        result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
      if (x & 0x20000000000000 > 0)
        result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
      if (x & 0x10000000000000 > 0)
        result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
      if (x & 0x8000000000000 > 0)
        result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
      if (x & 0x4000000000000 > 0)
        result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
      if (x & 0x2000000000000 > 0)
        result = result * 0x1000162E525EE054754457D5995292026 >> 128;
      if (x & 0x1000000000000 > 0)
        result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
      if (x & 0x800000000000 > 0)
        result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
      if (x & 0x400000000000 > 0)
        result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
      if (x & 0x200000000000 > 0)
        result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
      if (x & 0x100000000000 > 0)
        result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
      if (x & 0x80000000000 > 0)
        result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
      if (x & 0x40000000000 > 0)
        result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
      if (x & 0x20000000000 > 0)
        result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
      if (x & 0x10000000000 > 0)
        result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
      if (x & 0x8000000000 > 0)
        result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
      if (x & 0x4000000000 > 0)
        result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
      if (x & 0x2000000000 > 0)
        result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
      if (x & 0x1000000000 > 0)
        result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
      if (x & 0x800000000 > 0)
        result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
      if (x & 0x400000000 > 0)
        result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
      if (x & 0x200000000 > 0)
        result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
      if (x & 0x100000000 > 0)
        result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
      if (x & 0x80000000 > 0)
        result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
      if (x & 0x40000000 > 0)
        result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
      if (x & 0x20000000 > 0)
        result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
      if (x & 0x10000000 > 0)
        result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
      if (x & 0x8000000 > 0)
        result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
      if (x & 0x4000000 > 0)
        result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
      if (x & 0x2000000 > 0)
        result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
      if (x & 0x1000000 > 0)
        result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
      if (x & 0x800000 > 0)
        result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
      if (x & 0x400000 > 0)
        result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
      if (x & 0x200000 > 0)
        result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
      if (x & 0x100000 > 0)
        result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
      if (x & 0x80000 > 0)
        result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
      if (x & 0x40000 > 0)
        result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
      if (x & 0x20000 > 0)
        result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
      if (x & 0x10000 > 0)
        result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
      if (x & 0x8000 > 0)
        result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
      if (x & 0x4000 > 0)
        result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
      if (x & 0x2000 > 0)
        result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
      if (x & 0x1000 > 0)
        result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
      if (x & 0x800 > 0)
        result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
      if (x & 0x400 > 0)
        result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
      if (x & 0x200 > 0)
        result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
      if (x & 0x100 > 0)
        result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
      if (x & 0x80 > 0)
        result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
      if (x & 0x40 > 0)
        result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
      if (x & 0x20 > 0)
        result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
      if (x & 0x10 > 0)
        result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
      if (x & 0x8 > 0)
        result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
      if (x & 0x4 > 0)
        result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
      if (x & 0x2 > 0)
        result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
      if (x & 0x1 > 0)
        result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;

      result >>= uint256 (int256 (63 - (x >> 64)));
      require (result <= uint256 (int256 (MAX_64x64)));

      return int128 (int256 (result));
    }
  }

  /**
   * Calculate natural exponent of x.  Revert on overflow.
   *
   * @param x signed 64.64-bit fixed point number
   * @return signed 64.64-bit fixed point number
   */
  function exp (int128 x) internal pure returns (int128) {
    unchecked {
      require (x < 0x400000000000000000); // Overflow

      if (x < -0x400000000000000000) return 0; // Underflow

      return exp_2 (
          int128 (int256 (x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
    }
  }

  /**
   * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
   * integer numbers.  Revert on overflow or when y is zero.
   *
   * @param x unsigned 256-bit integer number
   * @param y unsigned 256-bit integer number
   * @return unsigned 64.64-bit fixed point number
   */
  function divuu (uint256 x, uint256 y) private pure returns (uint128) {
    unchecked {
      require (y != 0);

      uint256 result;

      if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
        result = (x << 64) / y;
      else {
        uint256 msb = 192;
        uint256 xc = x >> 192;
        if (xc >= 0x100000000) { xc >>= 32; msb += 32; }
        if (xc >= 0x10000) { xc >>= 16; msb += 16; }
        if (xc >= 0x100) { xc >>= 8; msb += 8; }
        if (xc >= 0x10) { xc >>= 4; msb += 4; }
        if (xc >= 0x4) { xc >>= 2; msb += 2; }
        if (xc >= 0x2) msb += 1;  // No need to shift xc anymore

        result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1);
        require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

        uint256 hi = result * (y >> 128);
        uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);

        uint256 xh = x >> 192;
        uint256 xl = x << 64;

        if (xl < lo) xh -= 1;
        xl -= lo; // We rely on overflow behavior here
        lo = hi << 128;
        if (xl < lo) xh -= 1;
        xl -= lo; // We rely on overflow behavior here

        result += xh == hi >> 128 ? xl / y : 1;
      }

      require (result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
      return uint128 (result);
    }
  }

  /**
   * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
   * number.
   *
   * @param x unsigned 256-bit integer number
   * @return unsigned 128-bit integer number
   */
  function sqrtu (uint256 x) private pure returns (uint128) {
    unchecked {
      if (x == 0) return 0;
      else {
        uint256 xx = x;
        uint256 r = 1;
        if (xx >= 0x100000000000000000000000000000000) { xx >>= 128; r <<= 64; }
        if (xx >= 0x10000000000000000) { xx >>= 64; r <<= 32; }
        if (xx >= 0x100000000) { xx >>= 32; r <<= 16; }
        if (xx >= 0x10000) { xx >>= 16; r <<= 8; }
        if (xx >= 0x100) { xx >>= 8; r <<= 4; }
        if (xx >= 0x10) { xx >>= 4; r <<= 2; }
        if (xx >= 0x4) { r <<= 1; }
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1;
        r = (r + x / r) >> 1; // Seven iterations should be enough
        uint256 r1 = x / r;
        return uint128 (r < r1 ? r : r1);
      }
    }
  }
}

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

interface IOwnable {
    function policy() external view returns (address);

    function renounceManagement() external;

    function pushManagement(address newOwner_) external;

    function pullManagement() external;
}

//SPDX-License-Identifier: UNLICENSE
pragma solidity >=0.5.0;

interface IStaking {
    function updateRewardPerInterval(uint256 _rewardPerInterval) external;
    function deposit(uint256 _pid, uint256 _amount, address _account) external;
}

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

interface IUniswapV2Pair {
    struct Observation {
        uint256 timestamp;
        uint256 reserve0Cumulative;
        uint256 reserve1Cumulative;
    }

    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint);

    function fee() external view returns (uint);

    function balanceOf(address owner) external view returns (uint);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);

    function transfer(address to, uint value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint);

    function permit(
        address owner,
        address spender,
        uint value,
        uint deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(
        address indexed sender,
        uint amount0,
        uint amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function price0CumulativeLast() external view returns (uint);

    function price1CumulativeLast() external view returns (uint);

    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);

    function burn(address to) external returns (uint amount0, uint amount1);

    function swap(
        uint amount0Out,
        uint amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;

    function currentCumulativePrices()
        external
        view
        returns (
            uint256 reserve0Cumulative,
            uint256 reserve1Cumulative,
            uint256 blockTimestamp
        );

    function lastObservation() external view returns (Observation memory);

    /// SHADOW V2 ONLY
    function getAmountOut(
        uint amountIn,
        address tokenIn
    ) external view returns (uint amountOut);
}

//SPDX-License-Identifier: UNLICENSE
pragma solidity >=0.5.0;

interface IWomo {
    function rebase(
        uint256 epoch,
        uint256 indexDelta,
        bool positive
    ) external returns (uint256);

    function totalSupply() external view returns (uint256);

    function balanceOf(address user) external view returns (uint256);

    function tokensScalingFactor() external view returns (uint256);

    function mint(address to, uint256 amount) external;

    function mintUnderlying(address to, uint256 amount) external;

    function transferUnderlying(
        address to,
        uint256 value
    ) external returns (bool);

    function fragmentToToken(uint256 value) external view returns (uint256);

    function tokenToFragment(uint256 token) external view returns (uint256);

    function balanceOfUnderlying(address who) external view returns (uint256);

    function transfer(address to, uint256 amount) external returns (bool);

    function approve(address to, uint amount) external;

    function grantRole(bytes32 role, address account) external;
}

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

library LowGasSafeMath {
    /// @notice Returns x + y, reverts if sum overflows uint256
    /// @param x The augend
    /// @param y The addend
    /// @return z The sum of x and y
    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x + y) >= x);
    }

    function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
        require((z = x + y) >= x);
    }

    /// @notice Returns x - y, reverts if underflows
    /// @param x The minuend
    /// @param y The subtrahend
    /// @return z The difference of x and y
    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x - y) <= x);
    }

    function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
        require((z = x - y) <= x);
    }

    /// @notice Returns x * y, reverts if overflows
    /// @param x The multiplicand
    /// @param y The multiplier
    /// @return z The product of x and y
    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require(x == 0 || (z = x * y) / x == y);
    }

    /// @notice Returns x + y, reverts if overflows or underflows
    /// @param x The augend
    /// @param y The addend
    /// @return z The sum of x and y
    function add(int256 x, int256 y) internal pure returns (int256 z) {
        require((z = x + y) >= x == (y >= 0));
    }

    /// @notice Returns x - y, reverts if overflows or underflows
    /// @param x The minuend
    /// @param y The subtrahend
    /// @return z The difference of x and y
    function sub(int256 x, int256 y) internal pure returns (int256 z) {
        require((z = x - y) <= x == (y >= 0));
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 100
  },
  "viaIR": true,
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IWomo","name":"_womo","type":"address"},{"internalType":"uint256","name":"_compoundRatio","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256","name":"_deflationCompensationPercentage","type":"uint256"},{"internalType":"uint256","name":"_fractionFactor","type":"uint256"},{"internalType":"uint256","name":"_rebaseDuration","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"initialBCV","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBCV","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"adjustment","type":"uint256"},{"indexed":false,"internalType":"bool","name":"addition","type":"bool"}],"name":"CompoundRatioAdjustment","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"},{"inputs":[],"name":"BPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FRACTION_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"addSyncPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"adjustment","outputs":[{"internalType":"bool","name":"add","type":"bool"},{"internalType":"uint256","name":"rate","type":"uint256"},{"internalType":"uint256","name":"target","type":"uint256"},{"internalType":"uint32","name":"buffer","type":"uint32"},{"internalType":"uint32","name":"lastTime","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"approveCaller","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"approvedCallers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newDuration","type":"uint256"}],"name":"changeRebaseDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"principal","type":"uint256"},{"internalType":"uint256","name":"ratio","type":"uint256"},{"internalType":"uint256","name":"n","type":"uint256"}],"name":"compound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"compoundRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"computedOnTheFly","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"disableCaller","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rebaseCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_pair","type":"address"}],"name":"removeSyncPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_addition","type":"bool"},{"internalType":"uint256","name":"_increment","type":"uint256"},{"internalType":"uint256","name":"_target","type":"uint256"},{"internalType":"uint32","name":"_buffer","type":"uint32"}],"name":"setAdjustment","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_percentage","type":"uint256"}],"name":"setCompensationPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_compoundRatio","type":"uint256"}],"name":"setCompounRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_finalSupply","type":"uint256"}],"name":"setFinalSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_computedOnTheFly","type":"bool"}],"name":"setFlyComputed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IStaking","name":"_staking","type":"address"}],"name":"setStakingS","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IStaking","name":"_staking","type":"address"}],"name":"setStakingUSDC","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"syncPairs","outputs":[{"internalType":"contract IUniswapV2Pair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toogleAutoStakingAdjustmen","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"useAutoStakingAdjustment","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"womo","outputs":[{"internalType":"contract IWomo","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000003e08cb3067dc198fc313e1789347c9ae72c079d40000000000000000000000000000000000000000000000000048a72aa9a8200000000000000000000000000000000000000000000000000000000000680f2e7800000000000000000000000000000000000000000000000000000000000013880000000000000000000000000000000000000000000000000000000000000384000000000000000000000000000000000000000000000000000000000076a700

-----Decoded View---------------
Arg [0] : _womo (address): 0x3E08Cb3067dC198FC313E1789347c9AE72c079d4
Arg [1] : _compoundRatio (uint256): 20450000000000000
Arg [2] : _startTime (uint256): 1745825400
Arg [3] : _deflationCompensationPercentage (uint256): 5000
Arg [4] : _fractionFactor (uint256): 900
Arg [5] : _rebaseDuration (uint256): 7776000

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000003e08cb3067dc198fc313e1789347c9ae72c079d4
Arg [1] : 0000000000000000000000000000000000000000000000000048a72aa9a82000
Arg [2] : 00000000000000000000000000000000000000000000000000000000680f2e78
Arg [3] : 0000000000000000000000000000000000000000000000000000000000001388
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000384
Arg [5] : 000000000000000000000000000000000000000000000000000000000076a700