staked TRSY

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.19;

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

/*
    ███████╗██████╗  ██████╗    ██████╗  ██████╗
    ██╔════╝██╔══██╗██╔════╝    ╚════██╗██╔═████╗
    █████╗  ██████╔╝██║          █████╔╝██║██╔██║
    ██╔══╝  ██╔══██╗██║         ██╔═══╝ ████╔╝██║
    ███████╗██║  ██║╚██████╗    ███████╗╚██████╔╝
    ╚══════╝╚═╝  ╚═╝ ╚═════╝    ╚══════╝ ╚═════╝
*/

/**
 *  @title Modern ERC-20 implementation.
 *  @dev   Acknowledgements to Solmate, OpenZeppelin, and DSS for inspiring this code.
 */
contract ERC20 is IERC20 {
  /**
   *
   */
  /**
   * ERC-20 **
   */
  /**
   *
   */
  string public override name;
  string public override symbol;

  uint8 public override decimals;

  uint256 public override totalSupply;

  mapping(address => uint256) public override balanceOf;

  mapping(address => mapping(address => uint256)) public override allowance;

  /**
   *
   */
  /**
   * ERC-2612 **
   */
  /**
   *
   */

  // PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256
  // nonce,uint256 deadline)");
  bytes32 public constant override PERMIT_TYPEHASH =
    0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

  mapping(address => uint256) public override nonces;

  /**
   *  @param name_     The name of the token.
   *  @param symbol_   The symbol of the token.
   *  @param decimals_ The decimal precision used by the token.
   */
  constructor(string memory name_, string memory symbol_, uint8 decimals_) {
    name = name_;
    symbol = symbol_;
    decimals = decimals_;
  }

  /**
   *
   */
  /**
   * External Functions **
   */
  /**
   *
   */
  function approve(address spender_, uint256 amount_) external override returns (bool success_) {
    _approve(msg.sender, spender_, amount_);
    return true;
  }

  function decreaseAllowance(address spender_, uint256 subtractedAmount_)
    external
    override
    returns (bool success_)
  {
    _decreaseAllowance(msg.sender, spender_, subtractedAmount_);
    return true;
  }

  function increaseAllowance(address spender_, uint256 addedAmount_)
    external
    override
    returns (bool success_)
  {
    _approve(msg.sender, spender_, allowance[msg.sender][spender_] + addedAmount_);
    return true;
  }

  function permit(
    address owner_,
    address spender_,
    uint256 amount_,
    uint256 deadline_,
    uint8 v_,
    bytes32 r_,
    bytes32 s_
  ) external override {
    require(deadline_ >= block.timestamp, "ERC20:P:EXPIRED");

    // Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf),
    // defines
    // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}.
    require(
      uint256(s_) <= uint256(0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0)
        && (v_ == 27 || v_ == 28),
      "ERC20:P:MALLEABLE"
    );

    // Nonce realistically cannot overflow.
    unchecked {
      bytes32 digest = keccak256(
        abi.encodePacked(
          "\x19\x01",
          DOMAIN_SEPARATOR(),
          keccak256(
            abi.encode(PERMIT_TYPEHASH, owner_, spender_, amount_, nonces[owner_]++, deadline_)
          )
        )
      );

      address recoveredAddress = ecrecover(digest, v_, r_, s_);

      require(recoveredAddress == owner_ && owner_ != address(0), "ERC20:P:INVALID_SIGNATURE");
    }

    _approve(owner_, spender_, amount_);
  }

  function transfer(address recipient_, uint256 amount_) external override returns (bool success_) {
    _transfer(msg.sender, recipient_, amount_);
    return true;
  }

  function transferFrom(address owner_, address recipient_, uint256 amount_)
    external
    override
    returns (bool success_)
  {
    _decreaseAllowance(owner_, msg.sender, amount_);
    _transfer(owner_, recipient_, amount_);
    return true;
  }

  /**
   *
   */
  /**
   * View Functions **
   */
  /**
   *
   */
  function DOMAIN_SEPARATOR() public view override returns (bytes32 domainSeparator_) {
    return keccak256(
      abi.encode(
        keccak256(
          "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        ),
        keccak256(bytes(name)),
        keccak256(bytes("1")),
        block.chainid,
        address(this)
      )
    );
  }

  /**
   *
   */
  /**
   * Internal Functions **
   */
  /**
   *
   */
  function _approve(address owner_, address spender_, uint256 amount_) internal {
    emit Approval(owner_, spender_, allowance[owner_][spender_] = amount_);
  }

  function _burn(address owner_, uint256 amount_) internal {
    balanceOf[owner_] -= amount_;

    // Cannot underflow because a user's balance will never be larger than the total supply.
    unchecked {
      totalSupply -= amount_;
    }

    emit Transfer(owner_, address(0), amount_);

    _afterTokenTransfer(owner_, address(0x0), amount_);
  }

  function _decreaseAllowance(address owner_, address spender_, uint256 subtractedAmount_) internal {
    uint256 spenderAllowance = allowance[owner_][spender_]; // Cache to memory.

    if (spenderAllowance != type(uint256).max) {
      _approve(owner_, spender_, spenderAllowance - subtractedAmount_);
    }
  }

  function _mint(address recipient_, uint256 amount_) internal {
    totalSupply += amount_;

    // Cannot overflow because totalSupply would first overflow in the statement above.
    unchecked {
      balanceOf[recipient_] += amount_;
    }

    emit Transfer(address(0), recipient_, amount_);

    _afterTokenTransfer(address(0x0), recipient_, amount_);
  }

  function _transfer(address owner_, address recipient_, uint256 amount_) internal {
    balanceOf[owner_] -= amount_;

    // Cannot overflow because minting prevents overflow of totalSupply, and sum of user balances ==
    // totalSupply.
    unchecked {
      balanceOf[recipient_] += amount_;
    }

    emit Transfer(owner_, recipient_, amount_);

    _afterTokenTransfer(owner_, recipient_, amount_);
  }

  function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.7;

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

/**
 * @title Small Library to standardize erc20 token interactions.
 */
library ERC20Helper {
  /**
   *
   */
  /**
   * Internal Functions **
   */
  /**
   *
   */
  function transfer(address token_, address to_, uint256 amount_) internal returns (bool success_) {
    return _call(token_, abi.encodeWithSelector(IERC20Like.transfer.selector, to_, amount_));
  }

  function transferFrom(address token_, address from_, address to_, uint256 amount_)
    internal
    returns (bool success_)
  {
    return
      _call(token_, abi.encodeWithSelector(IERC20Like.transferFrom.selector, from_, to_, amount_));
  }

  function approve(address token_, address spender_, uint256 amount_)
    internal
    returns (bool success_)
  {
    // If setting approval to zero fails, return false.
    if (!_call(token_, abi.encodeWithSelector(IERC20Like.approve.selector, spender_, uint256(0)))) {
      return false;
    }

    // If `amount_` is zero, return true as the previous step already did this.
    if (amount_ == uint256(0)) return true;

    // Return the result of setting the approval to `amount_`.
    return _call(token_, abi.encodeWithSelector(IERC20Like.approve.selector, spender_, amount_));
  }

  function _call(address token_, bytes memory data_) private returns (bool success_) {
    if (token_.code.length == uint256(0)) return false;

    bytes memory returnData;
    (success_, returnData) = token_.call(data_);

    return success_ && (returnData.length == uint256(0) || abi.decode(returnData, (bool)));
  }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.19;

/// @title Interface of the ERC20 standard as defined in the EIP, including EIP-2612 permit
/// functionality.
interface IERC20 {
  /**
   *
   */
  /**
   * Events **
   */
  /**
   *
   */

  /**
   *  @dev   Emitted when one account has set the allowance of another account over their tokens.
   *  @param owner_   Account that tokens are approved from.
   *  @param spender_ Account that tokens are approved for.
   *  @param amount_  Amount of tokens that have been approved.
   */
  event Approval(address indexed owner_, address indexed spender_, uint256 amount_);

  /**
   *  @dev   Emitted when tokens have moved from one account to another.
   *  @param owner_     Account that tokens have moved from.
   *  @param recipient_ Account that tokens have moved to.
   *  @param amount_    Amount of tokens that have been transferred.
   */
  event Transfer(address indexed owner_, address indexed recipient_, uint256 amount_);

  /**
   *
   */
  /**
   * External Functions **
   */
  /**
   *
   */

  /**
   *  @dev    Function that allows one account to set the allowance of another account over their
   * tokens.
   *          Emits an {Approval} event.
   *  @param  spender_ Account that tokens are approved for.
   *  @param  amount_  Amount of tokens that have been approved.
   *  @return success_ Boolean indicating whether the operation succeeded.
   */
  function approve(address spender_, uint256 amount_) external returns (bool success_);

  /**
   *  @dev    Function that allows one account to decrease the allowance of another account over
   * their tokens.
   *          Emits an {Approval} event.
   *  @param  spender_          Account that tokens are approved for.
   *  @param  subtractedAmount_ Amount to decrease approval by.
   *  @return success_          Boolean indicating whether the operation succeeded.
   */
  function decreaseAllowance(address spender_, uint256 subtractedAmount_)
    external
    returns (bool success_);

  /**
   *  @dev    Function that allows one account to increase the allowance of another account over
   * their tokens.
   *          Emits an {Approval} event.
   *  @param  spender_     Account that tokens are approved for.
   *  @param  addedAmount_ Amount to increase approval by.
   *  @return success_     Boolean indicating whether the operation succeeded.
   */
  function increaseAllowance(address spender_, uint256 addedAmount_)
    external
    returns (bool success_);

  /**
   *  @dev   Approve by signature.
   *  @param owner_    Owner address that signed the permit.
   *  @param spender_  Spender of the permit.
   *  @param amount_   Permit approval spend limit.
   *  @param deadline_ Deadline after which the permit is invalid.
   *  @param v_        ECDSA signature v component.
   *  @param r_        ECDSA signature r component.
   *  @param s_        ECDSA signature s component.
   */
  function permit(
    address owner_,
    address spender_,
    uint256 amount_,
    uint256 deadline_,
    uint8 v_,
    bytes32 r_,
    bytes32 s_
  ) external;

  /**
   *  @dev    Moves an amount of tokens from `msg.sender` to a specified account.
   *          Emits a {Transfer} event.
   *  @param  recipient_ Account that receives tokens.
   *  @param  amount_    Amount of tokens that are transferred.
   *  @return success_   Boolean indicating whether the operation succeeded.
   */
  function transfer(address recipient_, uint256 amount_) external returns (bool success_);

  /**
   *  @dev    Moves a pre-approved amount of tokens from a sender to a specified account.
   *          Emits a {Transfer} event.
   *          Emits an {Approval} event.
   *  @param  owner_     Account that tokens are moving from.
   *  @param  recipient_ Account that receives tokens.
   *  @param  amount_    Amount of tokens that are transferred.
   *  @return success_   Boolean indicating whether the operation succeeded.
   */
  function transferFrom(address owner_, address recipient_, uint256 amount_)
    external
    returns (bool success_);

  /**
   *
   */
  /**
   * View Functions **
   */
  /**
   *
   */

  /**
   *  @dev    Returns the allowance that one account has given another over their tokens.
   *  @param  owner_     Account that tokens are approved from.
   *  @param  spender_   Account that tokens are approved for.
   *  @return allowance_ Allowance that one account has given another over their tokens.
   */
  function allowance(address owner_, address spender_) external view returns (uint256 allowance_);

  /**
   *  @dev    Returns the amount of tokens owned by a given account.
   *  @param  account_ Account that owns the tokens.
   *  @return balance_ Amount of tokens owned by a given account.
   */
  function balanceOf(address account_) external view returns (uint256 balance_);

  /**
   *  @dev    Returns the decimal precision used by the token.
   *  @return decimals_ The decimal precision used by the token.
   */
  function decimals() external view returns (uint8 decimals_);

  /**
   *  @dev    Returns the signature domain separator.
   *  @return domainSeparator_ The signature domain separator.
   */
  function DOMAIN_SEPARATOR() external view returns (bytes32 domainSeparator_);

  /**
   *  @dev    Returns the name of the token.
   *  @return name_ The name of the token.
   */
  function name() external view returns (string memory name_);

  /**
   *  @dev    Returns the nonce for the given owner.
   *  @param  owner_  The address of the owner account.
   *  @return nonce_ The nonce for the given owner.
   */
  function nonces(address owner_) external view returns (uint256 nonce_);

  /**
   *  @dev    Returns the permit type hash.
   *  @return permitTypehash_ The permit type hash.
   */
  function PERMIT_TYPEHASH() external view returns (bytes32 permitTypehash_);

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

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

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.7;

/// @title Interface of the ERC20 standard as needed by ERC20Helper.
interface IERC20Like {
  function approve(address spender_, uint256 amount_) external returns (bool success_);

  function transfer(address recipient_, uint256 amount_) external returns (bool success_);

  function transferFrom(address owner_, address recipient_, uint256 amount_)
    external
    returns (bool success_);
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.19;

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

/// @title A standard for tokenized Vaults with a single underlying ERC-20 token.
interface IERC4626 is IERC20 {
  /**
   *
   */
  /**
   * Events **
   */
  /**
   *
   */

  /**
   *  @dev   `caller_` has exchanged `assets_` for `shares_` and transferred them to `owner_`.
   *         MUST be emitted when assets are deposited via the `deposit` or `mint` methods.
   *  @param caller_ The caller of the function that emitted the `Deposit` event.
   *  @param owner_  The owner of the shares.
   *  @param assets_ The amount of assets deposited.
   *  @param shares_ The amount of shares minted.
   */
  event Deposit(address indexed caller_, address indexed owner_, uint256 assets_, uint256 shares_);

  /**
   *  @dev   `caller_` has exchanged `shares_`, owned by `owner_`, for `assets_`, and
   * transferred them to `receiver_`.
   *         MUST be emitted when assets are withdrawn via the `withdraw` or `redeem` methods.
   *  @param caller_   The caller of the function that emitted the `Withdraw` event.
   *  @param receiver_ The receiver of the assets.
   *  @param owner_    The owner of the shares.
   *  @param assets_   The amount of assets withdrawn.
   *  @param shares_   The amount of shares burned.
   */
  event Withdraw(
    address indexed caller_,
    address indexed receiver_,
    address indexed owner_,
    uint256 assets_,
    uint256 shares_
  );

  /**
   *
   */
  /**
   * State Variables **
   */
  /**
   *
   */

  /**
   *  @dev    The address of the underlying asset used by the Vault.
   *          MUST be a contract that implements the ERC-20 standard.
   *          MUST NOT revert.
   *  @return asset_ The address of the underlying asset.
   */
  function asset() external view returns (address asset_);

  /**
   *
   */
  /**
   * State Changing Functions **
   */
  /**
   *
   */

  /**
   *  @dev    Mints `shares_` to `receiver_` by depositing `assets_` into the Vault.
   *          MUST emit the {Deposit} event.
   *          MUST revert if all of the assets cannot be deposited (due to insufficient approval,
   * deposit limits, slippage, etc).
   *  @param  assets_   The amount of assets to deposit.
   *  @param  receiver_ The receiver of the shares.
   *  @return shares_   The amount of shares minted.
   */
  function deposit(uint256 assets_, address receiver_) external returns (uint256 shares_);

  /**
   *  @dev    Mints `shares_` to `receiver_` by depositing `assets_` into the Vault.
   *          MUST emit the {Deposit} event.
   *          MUST revert if all of shares cannot be minted (due to insufficient approval, deposit
   * limits, slippage, etc).
   *  @param  shares_   The amount of shares to mint.
   *  @param  receiver_ The receiver of the shares.
   *  @return assets_   The amount of assets deposited.
   */
  function mint(uint256 shares_, address receiver_) external returns (uint256 assets_);

  /**
   *  @dev    Burns `shares_` from `owner_` and sends `assets_` to `receiver_`.
   *          MUST emit the {Withdraw} event.
   *          MUST revert if all of the shares cannot be redeemed (due to insufficient shares,
   * withdrawal limits, slippage, etc).
   *  @param  shares_   The amount of shares to redeem.
   *  @param  receiver_ The receiver of the assets.
   *  @param  owner_    The owner of the shares.
   *  @return assets_   The amount of assets sent to the receiver.
   */
  function redeem(uint256 shares_, address receiver_, address owner_)
    external
    returns (uint256 assets_);

  /**
   *  @dev    Burns `shares_` from `owner_` and sends `assets_` to `receiver_`.
   *          MUST emit the {Withdraw} event.
   *          MUST revert if all of the assets cannot be withdrawn (due to insufficient assets,
   * withdrawal limits, slippage, etc).
   *  @param  assets_   The amount of assets to withdraw.
   *  @param  receiver_ The receiver of the assets.
   *  @param  owner_    The owner of the assets.
   *  @return shares_   The amount of shares burned from the owner.
   */
  function withdraw(uint256 assets_, address receiver_, address owner_)
    external
    returns (uint256 shares_);

  /**
   *
   */
  /**
   * View Functions **
   */
  /**
   *
   */

  /**
   *  @dev    The amount of `assets_` the `shares_` are currently equivalent to.
   *          MUST NOT be inclusive of any fees that are charged against assets in the Vault.
   *          MUST NOT reflect slippage or other on-chain conditions when performing the actual
   * exchange.
   *          MUST NOT show any variations depending on the caller.
   *          MUST NOT revert.
   *  @param  shares_ The amount of shares to convert.
   *  @return assets_ The amount of equivalent assets.
   */
  function convertToAssets(uint256 shares_) external view returns (uint256 assets_);

  /**
   *  @dev    The amount of `shares_` the `assets_` are currently equivalent to.
   *          MUST NOT be inclusive of any fees that are charged against assets in the Vault.
   *          MUST NOT reflect slippage or other on-chain conditions when performing the actual
   * exchange.
   *          MUST NOT show any variations depending on the caller.
   *          MUST NOT revert.
   *  @param  assets_ The amount of assets to convert.
   *  @return shares_ The amount of equivalent shares.
   */
  function convertToShares(uint256 assets_) external view returns (uint256 shares_);

  /**
   *  @dev    Maximum amount of `assets_` that can be deposited on behalf of the `receiver_` through
   * a `deposit` call.
   *          MUST return a limited value if the receiver is subject to any limits, or the maximum
   * value otherwise.
   *          MUST NOT revert.
   *  @param  receiver_ The receiver of the assets.
   *  @return assets_   The maximum amount of assets that can be deposited.
   */
  function maxDeposit(address receiver_) external view returns (uint256 assets_);

  /**
   *  @dev    Maximum amount of `shares_` that can be minted on behalf of the `receiver_` through a
   * `mint` call.
   *          MUST return a limited value if the receiver is subject to any limits, or the maximum
   * value otherwise.
   *          MUST NOT revert.
   *  @param  receiver_ The receiver of the shares.
   *  @return shares_   The maximum amount of shares that can be minted.
   */
  function maxMint(address receiver_) external view returns (uint256 shares_);

  /**
   *  @dev    Maximum amount of `shares_` that can be redeemed from the `owner_` through
   * a `redeem` call.
   *          MUST return a limited value if the owner is subject to any limits, or the total
   * amount of owned shares otherwise.
   *          MUST NOT revert.
   *  @param  owner_  The owner of the shares.
   *  @return shares_ The maximum amount of shares that can be redeemed.
   */
  function maxRedeem(address owner_) external view returns (uint256 shares_);

  /**
   *  @dev    Maximum amount of `assets_` that can be withdrawn from the `owner_` through a
   * `withdraw` call.
   *          MUST return a limited value if the owner is subject to any limits, or the total amount
   * of owned assets otherwise.
   *          MUST NOT revert.
   *  @param  owner_  The owner of the assets.
   *  @return assets_ The maximum amount of assets that can be withdrawn.
   */
  function maxWithdraw(address owner_) external view returns (uint256 assets_);

  /**
   *  @dev    Allows an on-chain or off-chain user to simulate the effects of their deposit at the
   * current block, given current on-chain conditions.
   *          MUST return as close to and no more than the exact amount of shares that would be
   * minted in a `deposit` call in the same transaction.
   *          MUST NOT account for deposit limits like those returned from `maxDeposit` and should
   * always act as though the deposit would be accepted.
   *          MUST NOT revert.
   *  @param  assets_ The amount of assets to deposit.
   *  @return shares_ The amount of shares that would be minted.
   */
  function previewDeposit(uint256 assets_) external view returns (uint256 shares_);

  /**
   *  @dev    Allows an on-chain or off-chain user to simulate the effects of their mint at the
   * current block, given current on-chain conditions.
   *          MUST return as close to and no fewer than the exact amount of assets that would be
   * deposited in a `mint` call in the same transaction.
   *          MUST NOT account for mint limits like those returned from `maxMint` and should always
   * act as though the minting would be accepted.
   *          MUST NOT revert.
   *  @param  shares_ The amount of shares to mint.
   *  @return assets_ The amount of assets that would be deposited.
   */
  function previewMint(uint256 shares_) external view returns (uint256 assets_);

  /**
   *  @dev    Allows an on-chain or off-chain user to simulate the effects of their redemption at
   * the current block, given current on-chain conditions.
   *          MUST return as close to and no more than the exact amount of assets that would be
   * withdrawn in a `redeem` call in the same transaction.
   *          MUST NOT account for redemption limits like those returned from `maxRedeem` and should
   * always act as though the redemption would be accepted.
   *          MUST NOT revert.
   *  @param  shares_ The amount of shares to redeem.
   *  @return assets_ The amount of assets that would be withdrawn.
   */
  function previewRedeem(uint256 shares_) external view returns (uint256 assets_);

  /**
   *  @dev    Allows an on-chain or off-chain user to simulate the effects of their withdrawal at
   * the current block, given current on-chain conditions.
   *          MUST return as close to and no fewer than the exact amount of shares that would be
   * burned in a `withdraw` call in the same transaction.
   *          MUST NOT account for withdrawal limits like those returned from `maxWithdraw` and
   * should always act as though the withdrawal would be accepted.
   *          MUST NOT revert.
   *  @param  assets_ The amount of assets to withdraw.
   *  @return shares_ The amount of shares that would be redeemed.
   */
  function previewWithdraw(uint256 assets_) external view returns (uint256 shares_);

  /**
   *  @dev    Total amount of the underlying asset that is managed by the Vault.
   *          SHOULD include compounding that occurs from any yields.
   *          MUST NOT revert.
   *  @return totalAssets_ The total amount of assets the Vault manages.
   */
  function totalAssets() external view returns (uint256 totalAssets_);
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.19;

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

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

/// @title A token that represents ownership of future revenues distributed linearly over time.
interface IRevenueDistributionToken is IERC20, IERC4626 {
  /**
   *
   */
  /**
   * Events **
   */
  /**
   *
   */

  /**
   *  @dev   Issuance parameters have been updated after a `_mint` or `_burn`.
   *  @param freeAssets_   Resulting `freeAssets` (y-intercept) value after accounting update.
   *  @param issuanceRate_ The new issuance rate of `asset` until `vestingPeriodFinish_`.
   */
  event IssuanceParamsUpdated(uint256 freeAssets_, uint256 issuanceRate_);

  /**
   *  @dev   `newOwner_` has accepted the transferral of RDT ownership from `previousOwner_`.
   *  @param previousOwner_ The previous RDT owner.
   *  @param newOwner_      The new RDT owner.
   */
  event OwnershipAccepted(address indexed previousOwner_, address indexed newOwner_);

  /**
   *  @dev   `owner_` has set the new pending owner of RDT to `pendingOwner_`.
   *  @param owner_        The current RDT owner.
   *  @param pendingOwner_ The new pending RDT owner.
   */
  event PendingOwnerSet(address indexed owner_, address indexed pendingOwner_);

  /**
   *  @dev   `owner_` has updated the RDT vesting schedule to end at `vestingPeriodFinish_`.
   *  @param owner_               The current RDT owner.
   *  @param vestingPeriodFinish_ When the unvested balance will finish vesting.
   */
  event VestingScheduleUpdated(address indexed owner_, uint256 vestingPeriodFinish_);

  /**
   *
   */
  /**
   * State Variables **
   */
  /**
   *
   */

  /**
   *  @dev The total amount of the underlying asset that is currently unlocked and is not
   * time-dependent.
   *       Analogous to the y-intercept in a linear function.
   */
  function freeAssets() external view returns (uint256 freeAssets_);

  /**
   *  @dev The rate of issuance of the vesting schedule that is currently active.
   *       Denominated as the amount of underlying assets vesting per second.
   */
  function issuanceRate() external view returns (uint256 issuanceRate_);

  /**
   *  @dev The timestamp of when the linear function was last recalculated.
   *       Analogous to t0 in a linear function.
   */
  function lastUpdated() external view returns (uint256 lastUpdated_);

  /**
   *  @dev The address of the account that is allowed to update the vesting schedule.
   */
  function owner() external view returns (address owner_);

  /**
   *  @dev The next owner, nominated by the current owner.
   */
  function pendingOwner() external view returns (address pendingOwner_);

  /**
   *  @dev The precision at which the issuance rate is measured.
   */
  function PRECISION() external view returns (uint256 precision_);

  /**
   *  @dev The end of the current vesting schedule.
   */
  function vestingPeriodFinish() external view returns (uint256 vestingPeriodFinish_);

  /**
   *
   */
  /**
   * Administrative Functions **
   */
  /**
   *
   */

  /**
   *  @dev Sets the pending owner as the new owner.
   *       Can be called only by the pending owner, and only after their nomination by the current
   * owner.
   */
  function acceptOwnership() external;

  /**
   *  @dev   Sets a new address as the pending owner.
   *  @param pendingOwner_ The address of the next potential owner.
   */
  function setPendingOwner(address pendingOwner_) external;

  /**
   *  @dev    Updates the current vesting formula based on the amount of total unvested funds in the
   * contract and the new `vestingPeriod_`.
   *  @param  vestingPeriod_ The amount of time over which all currently unaccounted underlying
   * assets will be vested over.
   *  @return issuanceRate_  The new issuance rate.
   *  @return freeAssets_    The new amount of underlying assets that are unlocked.
   */
  function updateVestingSchedule(uint256 vestingPeriod_)
    external
    returns (uint256 issuanceRate_, uint256 freeAssets_);

  /**
   *
   */
  /**
   * Staker Functions **
   */
  /**
   *
   */

  /**
   *  @dev    Does a ERC4626 `deposit` with a ERC-2612 `permit`.
   *  @param  assets_   The amount of `asset` to deposit.
   *  @param  receiver_ The receiver of the shares.
   *  @param  deadline_ The timestamp after which the `permit` signature is no longer valid.
   *  @param  v_        ECDSA signature v component.
   *  @param  r_        ECDSA signature r component.
   *  @param  s_        ECDSA signature s component.
   *  @return shares_   The amount of shares minted.
   */
  function depositWithPermit(
    uint256 assets_,
    address receiver_,
    uint256 deadline_,
    uint8 v_,
    bytes32 r_,
    bytes32 s_
  ) external returns (uint256 shares_);

  /**
   *  @dev    Does a ERC4626 `mint` with a ERC-2612 `permit`.
   *  @param  shares_    The amount of `shares` to mint.
   *  @param  receiver_  The receiver of the shares.
   *  @param  maxAssets_ The maximum amount of assets that can be taken, as per the permit.
   *  @param  deadline_  The timestamp after which the `permit` signature is no longer valid.
   *  @param  v_         ECDSA signature v component.
   *  @param  r_         ECDSA signature r component.
   *  @param  s_         ECDSA signature s component.
   *  @return assets_    The amount of shares deposited.
   */
  function mintWithPermit(
    uint256 shares_,
    address receiver_,
    uint256 maxAssets_,
    uint256 deadline_,
    uint8 v_,
    bytes32 r_,
    bytes32 s_
  ) external returns (uint256 assets_);

  /**
   *
   */
  /**
   * View Functions **
   */
  /**
   *
   */

  /**
   *  @dev    Returns the amount of underlying assets owned by the specified account.
   *  @param  account_ Address of the account.
   *  @return assets_  Amount of assets owned.
   */
  function balanceOfAssets(address account_) external view returns (uint256 assets_);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.19;

interface IRewardsDistributor {
  function updateAccounting(address _user1, address _user2) external;
  function activateFydeEmissions(address _user) external;
}

// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.19;

import {ERC20} from "./ERC20.sol";
import {ERC20Helper} from "./ERC20Helper.sol";

import {IRevenueDistributionToken} from "./IRevenueDistributionToken.sol";
import {IRewardsDistributor} from "../IRewardsDistributor.sol";

/*
    ██████╗ ██████╗ ████████╗
    ██╔══██╗██╔══██╗╚══██╔══╝
    ██████╔╝██║  ██║   ██║
    ██╔══██╗██║  ██║   ██║
    ██║  ██║██████╔╝   ██║
    ╚═╝  ╚═╝╚═════╝    ╚═╝
*/

abstract contract RevenueDistributionToken is IRevenueDistributionToken, ERC20 {
  uint256 public immutable override PRECISION; // Precision of rates, equals max deposit amounts
    // before rounding errors occur

  address public override asset; // Underlying ERC-20 asset used by ERC-4626 functionality.

  address public override owner; // Current owner of the contract, able to update the vesting
    // schedule.
  address public override pendingOwner; // Pending owner of the contract, able to accept ownership.

  uint256 public override freeAssets; // Amount of assets unlocked regardless of time passed.
  uint256 public override issuanceRate; // asset/second rate dependent on aggregate vesting
    // schedule.
  uint256 public override lastUpdated; // Timestamp of when issuance equation was last updated.
  uint256 public override vestingPeriodFinish; // Timestamp when current vesting schedule ends.

  uint256 private locked = 1; // Used in reentrancy check.

  /**
   *
   */
  /**
   * Modifiers **
   */
  /**
   *
   */
  modifier nonReentrant() {
    require(locked == 1, "RDT:LOCKED");

    locked = 2;

    _;

    locked = 1;
  }

  constructor(
    string memory name_,
    string memory symbol_,
    address owner_,
    address asset_,
    uint256 precision_
  ) ERC20(name_, symbol_, ERC20(asset_).decimals()) {
    require((owner = owner_) != address(0), "RDT:C:OWNER_ZERO_ADDRESS");

    asset = asset_; // Don't need to check zero address as ERC20(asset_).decimals() will fail in
      // ERC20 constructor.
    PRECISION = precision_;
  }

  /**
   *
   */
  /**
   * Administrative Functions **
   */
  /**
   *
   */
  function acceptOwnership() external virtual override {
    require(msg.sender == pendingOwner, "RDT:AO:NOT_PO");

    emit OwnershipAccepted(owner, msg.sender);

    owner = msg.sender;
    pendingOwner = address(0);
  }

  function setPendingOwner(address pendingOwner_) external virtual override {
    require(msg.sender == owner, "RDT:SPO:NOT_OWNER");

    pendingOwner = pendingOwner_;

    emit PendingOwnerSet(msg.sender, pendingOwner_);
  }

  function updateVestingSchedule(uint256 vestingPeriod_)
    external
    virtual
    override
    returns (uint256 issuanceRate_, uint256 freeAssets_)
  {
    require(msg.sender == owner, "RDT:UVS:NOT_OWNER");
    require(totalSupply != 0, "RDT:UVS:ZERO_SUPPLY");

    // Update "y-intercept" to reflect current available asset.
    freeAssets_ = freeAssets = totalAssets();

    // Calculate slope.
    issuanceRate_ = issuanceRate =
      ((ERC20(asset).balanceOf(address(this)) - freeAssets_) * PRECISION) / vestingPeriod_;

    // Update timestamp and period finish.
    vestingPeriodFinish = (lastUpdated = block.timestamp) + vestingPeriod_;

    emit IssuanceParamsUpdated(freeAssets_, issuanceRate_);
    emit VestingScheduleUpdated(msg.sender, vestingPeriodFinish);
  }

  /**
   *
   */
  /**
   * Staker Functions **
   */
  /**
   *
   */
  function deposit(uint256 assets_, address receiver_)
    external
    virtual
    override
    nonReentrant
    returns (uint256 shares_)
  {
    _mint(shares_ = previewDeposit(assets_), assets_, receiver_, msg.sender);
  }

  function depositWithPermit(
    uint256 assets_,
    address receiver_,
    uint256 deadline_,
    uint8 v_,
    bytes32 r_,
    bytes32 s_
  ) external virtual override nonReentrant returns (uint256 shares_) {
    ERC20(asset).permit(msg.sender, address(this), assets_, deadline_, v_, r_, s_);
    _mint(shares_ = previewDeposit(assets_), assets_, receiver_, msg.sender);
  }

  function mint(uint256 shares_, address receiver_)
    external
    virtual
    override
    nonReentrant
    returns (uint256 assets_)
  {
    _mint(shares_, assets_ = previewMint(shares_), receiver_, msg.sender);
  }

  function mintWithPermit(
    uint256 shares_,
    address receiver_,
    uint256 maxAssets_,
    uint256 deadline_,
    uint8 v_,
    bytes32 r_,
    bytes32 s_
  ) external virtual override nonReentrant returns (uint256 assets_) {
    require((assets_ = previewMint(shares_)) <= maxAssets_, "RDT:MWP:INSUFFICIENT_PERMIT");

    ERC20(asset).permit(msg.sender, address(this), maxAssets_, deadline_, v_, r_, s_);
    _mint(shares_, assets_, receiver_, msg.sender);
  }

  function redeem(uint256 shares_, address receiver_, address owner_)
    external
    virtual
    override
    nonReentrant
    returns (uint256 assets_)
  {
    _burn(shares_, assets_ = previewRedeem(shares_), receiver_, owner_, msg.sender);
  }

  function withdraw(uint256 assets_, address receiver_, address owner_)
    external
    virtual
    override
    nonReentrant
    returns (uint256 shares_)
  {
    _burn(shares_ = previewWithdraw(assets_), assets_, receiver_, owner_, msg.sender);
  }

  /**
   *
   */
  /**
   * Internal Functions **
   */
  /**
   *
   */
  function _mint(uint256 shares_, uint256 assets_, address receiver_, address caller_) internal {
    require(receiver_ != address(0), "RDT:M:ZERO_RECEIVER");
    require(shares_ != uint256(0), "RDT:M:ZERO_SHARES");
    require(assets_ != uint256(0), "RDT:M:ZERO_ASSETS");

    _mint(receiver_, shares_);

    uint256 freeAssetsCache = freeAssets = totalAssets() + assets_;

    uint256 issuanceRate_ = _updateIssuanceParams();

    emit Deposit(caller_, receiver_, assets_, shares_);
    emit IssuanceParamsUpdated(freeAssetsCache, issuanceRate_);

    require(ERC20Helper.transferFrom(asset, caller_, address(this), assets_), "RDT:M:TRANSFER_FROM");
    _activateFydeEmissions(receiver_);
  }

  function _burn(
    uint256 shares_,
    uint256 assets_,
    address receiver_,
    address owner_,
    address caller_
  ) internal {
    require(receiver_ != address(0), "RDT:B:ZERO_RECEIVER");
    require(shares_ != uint256(0), "RDT:B:ZERO_SHARES");
    require(assets_ != uint256(0), "RDT:B:ZERO_ASSETS");

    if (caller_ != owner_) _decreaseAllowance(owner_, caller_, shares_);

    _burn(owner_, shares_);

    uint256 freeAssetsCache = freeAssets = totalAssets() - assets_;

    uint256 issuanceRate_ = _updateIssuanceParams();

    emit Withdraw(caller_, receiver_, owner_, assets_, shares_);
    emit IssuanceParamsUpdated(freeAssetsCache, issuanceRate_);

    require(ERC20Helper.transfer(asset, receiver_, assets_), "RDT:B:TRANSFER");
  }

  function _updateIssuanceParams() internal returns (uint256 issuanceRate_) {
    return issuanceRate = (lastUpdated = block.timestamp) > vestingPeriodFinish ? 0 : issuanceRate;
  }

  /**
   *
   */
  /**
   * View Functions **
   */
  /**
   *
   */
  function balanceOfAssets(address account_)
    public
    view
    virtual
    override
    returns (uint256 balanceOfAssets_)
  {
    return convertToAssets(balanceOf[account_]);
  }

  function convertToAssets(uint256 shares_) public view virtual override returns (uint256 assets_) {
    uint256 supply = totalSupply; // Cache to stack.

    assets_ = supply == 0 ? shares_ : (shares_ * totalAssets()) / supply;
  }

  function convertToShares(uint256 assets_) public view virtual override returns (uint256 shares_) {
    uint256 supply = totalSupply; // Cache to stack.

    shares_ = supply == 0 ? assets_ : (assets_ * supply) / totalAssets();
  }

  function maxDeposit(address receiver_)
    external
    pure
    virtual
    override
    returns (uint256 maxAssets_)
  {
    receiver_; // Silence warning
    maxAssets_ = type(uint256).max;
  }

  function maxMint(address receiver_) external pure virtual override returns (uint256 maxShares_) {
    receiver_; // Silence warning
    maxShares_ = type(uint256).max;
  }

  function maxRedeem(address owner_) external view virtual override returns (uint256 maxShares_) {
    maxShares_ = balanceOf[owner_];
  }

  function maxWithdraw(address owner_) external view virtual override returns (uint256 maxAssets_) {
    maxAssets_ = balanceOfAssets(owner_);
  }

  function previewDeposit(uint256 assets_) public view virtual override returns (uint256 shares_) {
    // As per https://eips.ethereum.org/EIPS/eip-4626#security-considerations,
    // it should round DOWN if it’s calculating the amount of shares to issue to a user, given an
    // amount of assets provided.
    shares_ = convertToShares(assets_);
  }

  function previewMint(uint256 shares_) public view virtual override returns (uint256 assets_) {
    uint256 supply = totalSupply; // Cache to stack.

    // As per https://eips.ethereum.org/EIPS/eip-4626#security-considerations,
    // it should round UP if it’s calculating the amount of assets a user must provide, to be
    // issued a given amount of shares.
    assets_ = supply == 0 ? shares_ : _divRoundUp(shares_ * totalAssets(), supply);
  }

  function previewRedeem(uint256 shares_) public view virtual override returns (uint256 assets_) {
    // As per https://eips.ethereum.org/EIPS/eip-4626#security-considerations,
    // it should round DOWN if it’s calculating the amount of assets to send to a user, given
    // amount of shares returned.
    assets_ = convertToAssets(shares_);
  }

  function previewWithdraw(uint256 assets_) public view virtual override returns (uint256 shares_) {
    uint256 supply = totalSupply; // Cache to stack.

    // As per https://eips.ethereum.org/EIPS/eip-4626#security-considerations,
    // it should round UP if it’s calculating the amount of shares a user must return, to be sent
    // a given amount of assets.
    shares_ = supply == 0 ? assets_ : _divRoundUp(assets_ * supply, totalAssets());
  }

  function totalAssets() public view virtual override returns (uint256 totalManagedAssets_) {
    uint256 issuanceRate_ = issuanceRate;

    if (issuanceRate_ == 0) return freeAssets;

    uint256 vestingPeriodFinish_ = vestingPeriodFinish;
    uint256 lastUpdated_ = lastUpdated;

    uint256 vestingTimePassed = block.timestamp > vestingPeriodFinish_
      ? vestingPeriodFinish_ - lastUpdated_
      : block.timestamp - lastUpdated_;

    return ((issuanceRate_ * vestingTimePassed) / PRECISION) + freeAssets;
  }

  /**
   *
   */
  /**
   * Internal Functions **
   */
  /**
   *
   */
  function _divRoundUp(uint256 numerator_, uint256 divisor_)
    internal
    pure
    returns (uint256 result_)
  {
    return (numerator_ / divisor_) + (numerator_ % divisor_ > 0 ? 1 : 0);
  }

  function _activateFydeEmissions(address _user) internal {
    _getRewardsDistributor().activateFydeEmissions(_user);
  }

  function _getRewardsDistributor() internal view virtual returns (IRewardsDistributor);
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity >=0.8.7 <0.9.0;

/// Utils /////
import {RevenueDistributionToken} from "./revenueDistributionToken/RevenueDistributionToken.sol";
import {IRewardsDistributor} from "./IRewardsDistributor.sol";

contract sTRSY is RevenueDistributionToken {
  IRewardsDistributor public distributor;

  constructor(address _asset)
    RevenueDistributionToken("staked TRSY", "sTRSY", msg.sender, _asset, 1e27)
  {}

  function setRewardsDistributor(address _distributor) external {
    require(msg.sender == owner, "RDT:SPO:NOT_OWNER");
    distributor = IRewardsDistributor(_distributor);
  }

  function _afterTokenTransfer(address from, address to, uint256) internal override {
    distributor.updateAccounting(from, to);
  }

  function _getRewardsDistributor() internal view override returns (IRewardsDistributor) {
    return distributor;
  }
}

{
  "compilationTarget": {
    "src/yield/sTRSY.sol": "sTRSY"
  },
  "evmVersion": "paris",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [
    ":@openzeppelin/=lib/openzeppelin-contracts/",
    ":@uniswap/v3-core/=lib/v3-core/",
    ":@uniswap/v3-periphery/=lib/v3-periphery/",
    ":ds-test/=lib/forge-std/lib/ds-test/src/",
    ":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    ":forge-std/=lib/forge-std/src/",
    ":openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    ":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",
    ":openzeppelin/=lib/openzeppelin-contracts/contracts/",
    ":pendle-core-v2-public/=lib/pendle-core-v2-public/contracts/",
    ":solmate/=lib/solmate/src/",
    ":synthetix-v3/=lib/synthetix-v3/",
    ":v3-core/=lib/v3-core/contracts/",
    ":v3-periphery/=lib/v3-periphery/contracts/"
  ]
}