creation_sourcecode: /**
   *Submitted for verification at Etherscan.io on 2024-04-27
  */
  
  /**
   *Submitted for verification at Etherscan.io on 2024-04-22
  */
  
  // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.13;
  
  /**
   * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
   * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
   * be specified by overriding the virtual {_implementation} function.
   *
   * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
   * different contract through the {_delegate} function.
   *
   * The success and return data of the delegated call will be returned back to the caller of the proxy.
   */
  abstract contract Proxy {
      /**
       * @dev Delegates the current call to `implementation`.
       *
       * This function does not return to its internall call site, it will return directly to the external caller.
       */
      function _delegate(address implementation) internal virtual {
          assembly {
              // Copy msg.data. We take full control of memory in this inline assembly
              // block because it will not return to Solidity code. We overwrite the
              // Solidity scratch pad at memory position 0.
              calldatacopy(0, 0, calldatasize())
  
              // Call the implementation.
              // out and outsize are 0 because we don't know the size yet.
              let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
  
              // Copy the returned data.
              returndatacopy(0, 0, returndatasize())
  
              switch result
              // delegatecall returns 0 on error.
              case 0 {
                  revert(0, returndatasize())
              }
              default {
                  return(0, returndatasize())
              }
          }
      }
  
      /**
       * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
       * and {_fallback} should delegate.
       */
      function _implementation() internal view virtual returns (address);
  
      /**
       * @dev Delegates the current call to the address returned by `_implementation()`.
       *
       * This function does not return to its internall call site, it will return directly to the external caller.
       */
      function _fallback() internal virtual {
          _beforeFallback();
          _delegate(_implementation());
      }
  
      /**
       * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
       * function in the contract matches the call data.
       */
      fallback() external payable virtual {
          _fallback();
      }
  
      /**
       * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
       * is empty.
       */
      receive() external payable virtual {
          _fallback();
      }
  
      /**
       * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
       * call, or as part of the Solidity `fallback` or `receive` functions.
       *
       * If overriden should call `super._beforeFallback()`.
       */
      function _beforeFallback() internal virtual {}
  }
  contract DEVVETreasuryProxy is Proxy {
      
      // Storage position of the address of the current implementation
      bytes32 private constant implementationPosition = 
          keccak256("org.smartdefi.implementation.address");
      
      // Storage position of the owner of the contract
      bytes32 private constant proxyOwnerPosition = 
          keccak256("org.smartdefi.proxy.owner");
      
      /**
      * @dev Throws if called by any account other than the owner.
      */
      modifier onlyProxyOwner() {
          require (msg.sender == proxyOwner(), "Not Proxy owner");
          _;
      }
  
      /**
      * @dev the constructor sets owner
      */
      constructor() {
          _setUpgradeabilityOwner(msg.sender);
      }
  
      /**
       * @dev Allows the current owner to transfer ownership
       * @param _newOwner The address to transfer ownership to
       */
      function transferProxyOwnership(address _newOwner) 
          public onlyProxyOwner 
      {
          require(_newOwner != address(0));
          _setUpgradeabilityOwner(_newOwner);
      }
      
      /**
       * @dev Allows the proxy owner to upgrade the implementation
       * @param _impl address of the new implementation
       */
      function upgradeTo(address _impl) 
          public onlyProxyOwner
      {
          _upgradeTo(_impl);
      }
      
      /**
       * @dev Tells the address of the current implementation
       * @return impl address of the current implementation
       */
      function _implementation()
          internal
          view
          override
          returns (address impl)
      {
          bytes32 position = implementationPosition;
          assembly {
              impl := sload(position)
          }
      }
  
      function implementation() external view returns (address) {
          return _implementation();
      }
      
      /**
       * @dev Tells the address of the owner
       * @return owner the address of the owner
       */
      function proxyOwner() public view returns (address owner) {
          bytes32 position = proxyOwnerPosition;
          assembly {
              owner := sload(position)
          }
      }
      
      /**
       * @dev Sets the address of the current implementation
       * @param _newImplementation address of the new implementation
       */
      function _setImplementation(address _newImplementation) 
          internal 
      {
          bytes32 position = implementationPosition;
          assembly {
              sstore(position, _newImplementation)
          }
      }
      
      /**
       * @dev Upgrades the implementation address
       * @param _newImplementation address of the new implementation
       */
      function _upgradeTo(address _newImplementation) internal {
          address currentImplementation = _implementation();
          require(currentImplementation != _newImplementation);
          _setImplementation(_newImplementation);
      }
      
      /**
       * @dev Sets the address of the owner
       */
      function _setUpgradeabilityOwner(address _newProxyOwner) 
          internal 
      {
          bytes32 position = proxyOwnerPosition;
          assembly {
              sstore(position, _newProxyOwner)
          }
      }
  }