Update docs
This commit is contained in:
github-actions
@ -1,5 +1,5 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/Clones.sol)
|
||||
// OpenZeppelin Contracts (last updated v4.8.0) (proxy/Clones.sol)
|
||||
|
||||
pragma solidity ^0.8.0;
|
||||
|
||||
@ -25,11 +25,12 @@ library Clones {
|
||||
function clone(address implementation) internal returns (address instance) {
|
||||
/// @solidity memory-safe-assembly
|
||||
assembly {
|
||||
let ptr := mload(0x40)
|
||||
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
|
||||
mstore(add(ptr, 0x14), shl(0x60, implementation))
|
||||
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
|
||||
instance := create(0, ptr, 0x37)
|
||||
// Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
|
||||
// of the `implementation` address with the bytecode before the address.
|
||||
mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
|
||||
// Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
|
||||
mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
|
||||
instance := create(0, 0x09, 0x37)
|
||||
}
|
||||
require(instance != address(0), "ERC1167: create failed");
|
||||
}
|
||||
@ -44,11 +45,12 @@ library Clones {
|
||||
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
|
||||
/// @solidity memory-safe-assembly
|
||||
assembly {
|
||||
let ptr := mload(0x40)
|
||||
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
|
||||
mstore(add(ptr, 0x14), shl(0x60, implementation))
|
||||
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
|
||||
instance := create2(0, ptr, 0x37, salt)
|
||||
// Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
|
||||
// of the `implementation` address with the bytecode before the address.
|
||||
mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
|
||||
// Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
|
||||
mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
|
||||
instance := create2(0, 0x09, 0x37, salt)
|
||||
}
|
||||
require(instance != address(0), "ERC1167: create2 failed");
|
||||
}
|
||||
@ -64,13 +66,13 @@ library Clones {
|
||||
/// @solidity memory-safe-assembly
|
||||
assembly {
|
||||
let ptr := mload(0x40)
|
||||
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
|
||||
mstore(add(ptr, 0x14), shl(0x60, implementation))
|
||||
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
|
||||
mstore(add(ptr, 0x38), shl(0x60, deployer))
|
||||
mstore(add(ptr, 0x4c), salt)
|
||||
mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
|
||||
predicted := keccak256(add(ptr, 0x37), 0x55)
|
||||
mstore(add(ptr, 0x38), deployer)
|
||||
mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
|
||||
mstore(add(ptr, 0x14), implementation)
|
||||
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
|
||||
mstore(add(ptr, 0x58), salt)
|
||||
mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
|
||||
predicted := keccak256(add(ptr, 0x43), 0x55)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -26,7 +26,7 @@ A different family of proxies are beacon proxies. This pattern, popularized by D
|
||||
- {BeaconProxy}: A proxy that retrieves its implementation from a beacon contract.
|
||||
- {UpgradeableBeacon}: A beacon contract with a built in admin that can upgrade the {BeaconProxy} pointing to it.
|
||||
|
||||
In this pattern, the proxy contract doesn't hold the implementation address in storage like an ERC1967 proxy, instead the address is stored in a separate beacon contract. The `upgrade` operations that are sent to the beacon instead of to the proxy contract, and all proxies that follow that beacon are automatically upgraded.
|
||||
In this pattern, the proxy contract doesn't hold the implementation address in storage like an ERC1967 proxy. Instead, the address is stored in a separate beacon contract. The `upgrade` operations are sent to the beacon instead of to the proxy contract, and all proxies that follow that beacon are automatically upgraded.
|
||||
|
||||
Outside the realm of upgradeability, proxies can also be useful to make cheap contract clones, such as those created by an on-chain factory contract that creates many instances of the same contract. These instances are designed to be both cheap to deploy, and cheap to call.
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
|
||||
// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol)
|
||||
|
||||
pragma solidity ^0.8.2;
|
||||
|
||||
@ -73,7 +73,12 @@ abstract contract Initializable {
|
||||
|
||||
/**
|
||||
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
|
||||
* `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
|
||||
* `onlyInitializing` functions can be used to initialize parent contracts.
|
||||
*
|
||||
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
|
||||
* constructor.
|
||||
*
|
||||
* Emits an {Initialized} event.
|
||||
*/
|
||||
modifier initializer() {
|
||||
bool isTopLevelCall = !_initializing;
|
||||
@ -97,12 +102,18 @@ abstract contract Initializable {
|
||||
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
|
||||
* used to initialize parent contracts.
|
||||
*
|
||||
* `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
|
||||
* initialization step. This is essential to configure modules that are added through upgrades and that require
|
||||
* initialization.
|
||||
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
|
||||
* are added through upgrades and that require initialization.
|
||||
*
|
||||
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
|
||||
* cannot be nested. If one is invoked in the context of another, execution will revert.
|
||||
*
|
||||
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
|
||||
* a contract, executing them in the right order is up to the developer or operator.
|
||||
*
|
||||
* WARNING: setting the version to 255 will prevent any future reinitialization.
|
||||
*
|
||||
* Emits an {Initialized} event.
|
||||
*/
|
||||
modifier reinitializer(uint8 version) {
|
||||
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
|
||||
@ -127,6 +138,8 @@ abstract contract Initializable {
|
||||
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
|
||||
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
|
||||
* through proxies.
|
||||
*
|
||||
* Emits an {Initialized} event the first time it is successfully executed.
|
||||
*/
|
||||
function _disableInitializers() internal virtual {
|
||||
require(!_initializing, "Initializable: contract is initializing");
|
||||
@ -135,4 +148,18 @@ abstract contract Initializable {
|
||||
emit Initialized(type(uint8).max);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Internal function that returns the initialized version. Returns `_initialized`
|
||||
*/
|
||||
function _getInitializedVersion() internal view returns (uint8) {
|
||||
return _initialized;
|
||||
}
|
||||
|
||||
/**
|
||||
* @dev Internal function that returns the initialized version. Returns `_initializing`
|
||||
*/
|
||||
function _isInitializing() internal view returns (bool) {
|
||||
return _initializing;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)
|
||||
// OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/UUPSUpgradeable.sol)
|
||||
|
||||
pragma solidity ^0.8.0;
|
||||
|
||||
@ -46,7 +46,7 @@ abstract contract UUPSUpgradeable is IERC1822Proxiable, ERC1967Upgrade {
|
||||
|
||||
/**
|
||||
* @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
|
||||
* implementation. It is used to validate that the this implementation remains valid after an upgrade.
|
||||
* implementation. It is used to validate the implementation's compatibility when performing an upgrade.
|
||||
*
|
||||
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
|
||||
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
|
||||
|
||||
Reference in New Issue
Block a user