Contract Source Code:

/*

 █▀ █▀█ █▄░█ █ █▀▀ █▀▀ ▄▀█ █▀▀ ▀█▀ █▀█ █▀█ █▄█
 ▄█ █▄█ █░▀█ █ █▄▄ █▀░ █▀█ █▄▄ ░█░ █▄█ █▀▄ ░█░

  Trade on SonicFactory and have fun!
  Web:      https://sonicfactory.fun/

*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

library StorageSlot {
  function getAddressSlot(bytes32 _slot) internal view returns (address) {
    address addr;

    assembly {
      addr := sload(_slot)
    }

    return addr;
  }

  function setAddressSlot(bytes32 _slot, address _addr) internal {
    assembly {
      sstore(_slot, _addr)
    }
  }
}

contract Incubator_Proxy {
  bytes32 private constant ADMIN_SLOT = bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1);
  bytes32 private constant IMPLEMENTATION_SLOT = bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1);

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

  modifier onlyOwner() {
    if (msg.sender == owner()) {
      _;
    } else {
      _fallback();
    }
  }

  constructor() payable {
    _transferOwnership(msg.sender);
  }

  function owner() public view returns (address) {
    return StorageSlot.getAddressSlot(ADMIN_SLOT);
  }

  function transferOwnership(address newOwner) external onlyOwner {
    _transferOwnership(newOwner);
  }

  function getImplementation() external view returns (address) {
    return _getImplementation();
  }

  function setImplementation(address _implementation) external onlyOwner {
    _setImplementation(_implementation);
  }

  function _transferOwnership(address newOwner) private {
    require(newOwner != address(0));

    address oldOwner = owner();

    StorageSlot.setAddressSlot(ADMIN_SLOT, newOwner);

    emit OwnershipTransferred(oldOwner, newOwner);
  }

  function _getImplementation() private view returns (address) {
    return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT);
  }

  function _setImplementation(address _implementation) private {
    StorageSlot.setAddressSlot(IMPLEMENTATION_SLOT, _implementation);

    emit ImplementationUpgraded(_implementation);
  }

  function _delegate(address _implementation) private returns (bytes memory) {
    assembly {
      let csize := calldatasize()

      calldatacopy(0, 0, csize)

      let result := delegatecall(gas(), _implementation, 0, csize, 0, 0)
      let rsize := returndatasize()

      returndatacopy(0, 0, rsize)

      switch result
        case 0 { revert(0, rsize) }
        default { return(0, rsize) }
    }
  }

  function _fallback() private {
    _delegate(_getImplementation());
  }

  receive() external payable { _fallback(); }
  fallback() external payable { _fallback(); }
}