Upgradeability & smart contracts

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26; 

contract Implementation { 
    // state variables 
    uint256 public value; 
    address public owner ; 

    // Events 
    event ValueChanged(uint256 newValue); 

    // The constructor is replaced by an initializer function 
    // It can only be called once . 
    function initialize(address _owner) public { 
        require(owner == address(0), "already initialized"); 
        owner = _owner; 
    }

    // function to set a new value 
    // setValue allows the owner to change the value.
    function setValue(uint256 _newValue) public { 
        require(msg.sender == owner, "Not authorized ! "); 
        value = _newValue ; 
        emit ValueChanged(_newValue); 
    }

    //  getValue is a public function to  retrieve the current value 
    function getValue() public view returns (uint256) { 
        return value; 
    }
}

//SPDX-License-Identifier: MIT
pragma solidity 0.8.26; 

contract TransparentProxy { 
  // We use constant unique collision-resistant storage slots for the implementation & admin addresses 
  // to avoid storage collisions;

  // Storage slot with the address of the current implementation 
  bytes32 private constant IMPLEMENTATION_SLOT = bytes32(uint256(keccak256('eip1967.proxy.implementation')));
  // Storage slot with the address of the admin 
  bytes32 private constant ADMIN_SLOT = bytes32(uint256(keccak256('eip1967.proxy.admin'))); 

   event Upgraded(address indexed implementation); 
   event AdminChanged(address previousAdmin, address newAdmin);


  // The constructor sets the initial implementation and admin addresses . 
  constructor(address _implementation, address _admin) { 
    _setImplementation(_implementation) ; 
    _setAdmin(_admin); 
  }

  // The modifier checks if the caller is the admin. If not, it delegatesd the call to the implementation contract . 
  modifier ifAdmin () {
      if (msg.sender == _getAdmin()) { 
        _; 
      } else { 
        _fallback();
      }
  }

  // This 'upgradeTo' function allows the admin to upgrade the implementation.
  function upgradeTo(address _newImplementation) external ifAdmin { 
          _setImplementation(_newImplementation); 
          emit Upgraded(_newImplementation); 
  }



  // This 'changeAdmin' function allows changing the admin address . 
  function changeAdmin(address _newAdmin) external ifAdmin { 
      emit AdminChanged(_getAdmin(), _newAdmin); 
      _setAdmin(_newAdmin) ; 
  }


  //  the 'fallback'  function handle all calls to the proxy ,  delegating it to the implementation contract . 
  fallback() external { 
    _fallback(); 
  }



  // '_fallback' uses assembly to perform the actual  delegation to the implemetation contract using 
  // assembly for gas efficiency . 
    function _fallback() private {
        address _impl = _getImplementation();
        require(_impl != address(0), "Implementation not set");

        assembly {
            let ptr := mload(0x40)
            calldatacopy(ptr, 0, calldatasize())
            let result := delegatecall(gas(), _impl, ptr, calldatasize(), 0, 0)
            let size := returndatasize()
            returndatacopy(ptr, 0, size)

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





  // '_setImplementation', 'setAdmin' , '_getImplementation' , '_getAdmin' use assembly to interact with specific storage slots . 
  // Theses internal functions handle setting and getting the implementation and admin address using the defined storage slots . 
function _setImplementation(address _newImpl) private {
        require(_newImpl != address(0), "Invalid implementation address");
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            sstore(slot, _newImpl)
        }
    }

    function _setAdmin(address _newAdmin) private {
        require(_newAdmin != address(0), "Invalid admin address");
        bytes32 slot = ADMIN_SLOT;
        assembly {
            sstore(slot, _newAdmin)
        }
    }

    function _getImplementation() private view returns (address impl) {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            impl := sload(slot)
        }
    }

    function _getAdmin() private view returns (address adm) {
        bytes32 slot = ADMIN_SLOT;
        assembly {
            adm := sload(slot)
        }
    }


}

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

import {Script, console} from "../lib/forge-std/src/Script.sol";
import { Implementation } from "../src/Implementation.sol";
import { TransparentProxy } from "../src/TransparentProxy.sol"; 
import { Vm } from "../lib/forge-std/src/Vm.sol"; 

contract DeployScript is Script {
    function run() external {
      // the private key of the admin/deployer is retrieved thru the env variable.
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        address deployerAddress = vm.addr(deployerPrivateKey);

        // the deployment is wrapped in 'vm.startBroadcast' method 
        // which is foundry way of simulating sending tx from the specified private key. 
        vm.startBroadcast(deployerPrivateKey);

        // Deployment of the  Implementation contract firstly . 
        Implementation implementation = new Implementation();
        console.log("Implementation deployed at:", address(implementation));

        // Deployment of the TransparentProxy contract secondly . 
        // the address of the first deployed contract is provided as first param & 
        // the admin address is provided as second param. 
        TransparentProxy proxy = new TransparentProxy(address(implementation), deployerAddress);
        console.log("TransparentProxy deployed at:", address(proxy));
    }
}