You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
330 lines
9.1 KiB
330 lines
9.1 KiB
// SPDX-License-Identifier: MIT
|
|
// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
|
|
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
|
|
|
|
pragma solidity ^0.8.24;
|
|
|
|
/**
|
|
* @dev Library for reading and writing primitive types to specific storage slots.
|
|
*
|
|
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
|
|
* This library helps with reading and writing to such slots without the need for inline assembly.
|
|
*
|
|
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
|
|
*
|
|
* Example usage to set ERC-1967 implementation slot:
|
|
* ```solidity
|
|
* contract ERC1967 {
|
|
* // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
|
|
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
|
|
*
|
|
* function _getImplementation() internal view returns (address) {
|
|
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
|
|
* }
|
|
*
|
|
* function _setImplementation(address newImplementation) internal {
|
|
* require(newImplementation.code.length > 0);
|
|
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* Since version 5.1, this library also support writing and reading value types to and from transient storage.
|
|
*
|
|
* * Example using transient storage:
|
|
* ```solidity
|
|
* contract Lock {
|
|
* // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
|
|
* bytes32 internal constant _LOCK_SLOT = 0xf4678858b2b588224636b8522b729e7722d32fc491da849ed75b3fdf3c84f542;
|
|
*
|
|
* modifier locked() {
|
|
* require(!_LOCK_SLOT.asBoolean().tload());
|
|
*
|
|
* _LOCK_SLOT.asBoolean().tstore(true);
|
|
* _;
|
|
* _LOCK_SLOT.asBoolean().tstore(false);
|
|
* }
|
|
* }
|
|
* ```
|
|
*
|
|
* TIP: Consider using this library along with {SlotDerivation}.
|
|
*/
|
|
library StorageSlot {
|
|
struct AddressSlot {
|
|
address value;
|
|
}
|
|
|
|
struct BooleanSlot {
|
|
bool value;
|
|
}
|
|
|
|
struct Bytes32Slot {
|
|
bytes32 value;
|
|
}
|
|
|
|
struct Uint256Slot {
|
|
uint256 value;
|
|
}
|
|
|
|
struct Int256Slot {
|
|
int256 value;
|
|
}
|
|
|
|
struct StringSlot {
|
|
string value;
|
|
}
|
|
|
|
struct BytesSlot {
|
|
bytes value;
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
|
|
*/
|
|
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
|
|
*/
|
|
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
|
|
*/
|
|
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
|
|
*/
|
|
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `Int256Slot` with member `value` located at `slot`.
|
|
*/
|
|
function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `StringSlot` with member `value` located at `slot`.
|
|
*/
|
|
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
|
|
*/
|
|
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := store.slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `BytesSlot` with member `value` located at `slot`.
|
|
*/
|
|
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
|
|
*/
|
|
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
r.slot := store.slot
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev UDVT that represent a slot holding a address.
|
|
*/
|
|
type AddressSlotType is bytes32;
|
|
|
|
/**
|
|
* @dev Cast an arbitrary slot to a AddressSlotType.
|
|
*/
|
|
function asAddress(bytes32 slot) internal pure returns (AddressSlotType) {
|
|
return AddressSlotType.wrap(slot);
|
|
}
|
|
|
|
/**
|
|
* @dev UDVT that represent a slot holding a bool.
|
|
*/
|
|
type BooleanSlotType is bytes32;
|
|
|
|
/**
|
|
* @dev Cast an arbitrary slot to a BooleanSlotType.
|
|
*/
|
|
function asBoolean(bytes32 slot) internal pure returns (BooleanSlotType) {
|
|
return BooleanSlotType.wrap(slot);
|
|
}
|
|
|
|
/**
|
|
* @dev UDVT that represent a slot holding a bytes32.
|
|
*/
|
|
type Bytes32SlotType is bytes32;
|
|
|
|
/**
|
|
* @dev Cast an arbitrary slot to a Bytes32SlotType.
|
|
*/
|
|
function asBytes32(bytes32 slot) internal pure returns (Bytes32SlotType) {
|
|
return Bytes32SlotType.wrap(slot);
|
|
}
|
|
|
|
/**
|
|
* @dev UDVT that represent a slot holding a uint256.
|
|
*/
|
|
type Uint256SlotType is bytes32;
|
|
|
|
/**
|
|
* @dev Cast an arbitrary slot to a Uint256SlotType.
|
|
*/
|
|
function asUint256(bytes32 slot) internal pure returns (Uint256SlotType) {
|
|
return Uint256SlotType.wrap(slot);
|
|
}
|
|
|
|
/**
|
|
* @dev UDVT that represent a slot holding a int256.
|
|
*/
|
|
type Int256SlotType is bytes32;
|
|
|
|
/**
|
|
* @dev Cast an arbitrary slot to a Int256SlotType.
|
|
*/
|
|
function asInt256(bytes32 slot) internal pure returns (Int256SlotType) {
|
|
return Int256SlotType.wrap(slot);
|
|
}
|
|
|
|
/**
|
|
* @dev Load the value held at location `slot` in transient storage.
|
|
*/
|
|
function tload(AddressSlotType slot) internal view returns (address value) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
value := tload(slot)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Store `value` at location `slot` in transient storage.
|
|
*/
|
|
function tstore(AddressSlotType slot, address value) internal {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
tstore(slot, value)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Load the value held at location `slot` in transient storage.
|
|
*/
|
|
function tload(BooleanSlotType slot) internal view returns (bool value) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
value := tload(slot)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Store `value` at location `slot` in transient storage.
|
|
*/
|
|
function tstore(BooleanSlotType slot, bool value) internal {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
tstore(slot, value)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Load the value held at location `slot` in transient storage.
|
|
*/
|
|
function tload(Bytes32SlotType slot) internal view returns (bytes32 value) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
value := tload(slot)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Store `value` at location `slot` in transient storage.
|
|
*/
|
|
function tstore(Bytes32SlotType slot, bytes32 value) internal {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
tstore(slot, value)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Load the value held at location `slot` in transient storage.
|
|
*/
|
|
function tload(Uint256SlotType slot) internal view returns (uint256 value) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
value := tload(slot)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Store `value` at location `slot` in transient storage.
|
|
*/
|
|
function tstore(Uint256SlotType slot, uint256 value) internal {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
tstore(slot, value)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Load the value held at location `slot` in transient storage.
|
|
*/
|
|
function tload(Int256SlotType slot) internal view returns (int256 value) {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
value := tload(slot)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Store `value` at location `slot` in transient storage.
|
|
*/
|
|
function tstore(Int256SlotType slot, int256 value) internal {
|
|
/// @solidity memory-safe-assembly
|
|
assembly {
|
|
tstore(slot, value)
|
|
}
|
|
}
|
|
}
|
|
|