// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)pragmasolidity ^0.8.0;/**
* @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.
*/abstractcontractProxy{
/**
* @dev Delegates the current call to `implementation`.
*
* This function does not return to its internal call site, it will return directly to the external caller.
*/function_delegate(address implementation) internalvirtual{
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.case0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
/**
* @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
* and {_fallback} should delegate.
*/function_implementation() internalviewvirtualreturns (address);
/**
* @dev Delegates the current call to the address returned by `_implementation()`.
*
* This function does not return to its internal call site, it will return directly to the external caller.
*/function_fallback() internalvirtual{
_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() externalpayablevirtual{
_fallback();
}
/**
* @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
* is empty.
*/receive() externalpayablevirtual{
_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 overridden should call `super._beforeFallback()`.
*/function_beforeFallback() internalvirtual{}
}
Contract Source Code
File 2 of 3: UUPSProxy.sol
// SPDX-License-Identifier: AGPLv3pragmasolidity ^0.8.23;import { UUPSUtils } from"./UUPSUtils.sol";
import { Proxy } from"@openzeppelin/contracts/proxy/Proxy.sol";
/**
* @title UUPS (Universal Upgradeable Proxy Standard) Proxy
*
* NOTE:
* - Compliant with [Universal Upgradeable Proxy Standard](https://eips.ethereum.org/EIPS/eip-1822)
* - Compiiant with [Standard Proxy Storage Slots](https://eips.ethereum.org/EIPS/eip-1967)
* - Implements delegation of calls to other contracts, with proper forwarding of
* return values and bubbling of failures.
* - It defines a fallback function that delegates all calls to the implementation.
*/contractUUPSProxyisProxy{
/**
* @dev Proxy initialization function.
* This should only be called once and it is permission-less.
* @param initialAddress Initial logic contract code address to be used.
*/functioninitializeProxy(address initialAddress) external{
require(initialAddress !=address(0), "UUPSProxy: zero address");
require(UUPSUtils.implementation() ==address(0), "UUPSProxy: already initialized");
UUPSUtils.setImplementation(initialAddress);
}
/// @dev Proxy._implementation implementationfunction_implementation() internalvirtualoverrideviewreturns (address)
{
return UUPSUtils.implementation();
}
}
