实用工具

using MerkleTree for MerkleTree.Bytes32PushTree;
MerkleTree.Bytes32PushTree private _tree;

function setup(uint8 _depth, bytes32 _zero) public /* onlyOwner */ {
    root = _tree.setup(_depth, _zero);
}

function push(bytes32 leaf) public /* onlyOwner */ {
    (uint256 leafIndex, bytes32 currentRoot) = _tree.push(leaf);
    // 存储新根。
}

using MerkleTree for MerkleTree.Bytes32PushTree;
MerkleTree.Bytes32PushTree private _tree;

function setup(uint8 _depth, bytes32 _zero) public /* onlyOwner */ {
    root = _tree.setup(_depth, _zero, _hashFn);
}

function push(bytes32 leaf) public /* onlyOwner */ {
    (uint256 leafIndex, bytes32 currentRoot) = _tree.push(leaf, _hashFn);
    // 存储新根。
}

function _hashFn(bytes32 a, bytes32 b) internal view returns(bytes32) {
    // 自定义哈希函数实现
    // 保留为内部实现细节以
    // 保证始终使用相同的函数
}

function pop(Uint256Heap storage self) internal returns (uint256) {
    return pop(self, Comparators.gt);
}

function insert(Uint256Heap storage self, uint256 value) internal {
    insert(self, value, Comparators.gt);
}

function replace(Uint256Heap storage self, uint256 newValue) internal returns (uint256) {
    return replace(self, newValue, Comparators.gt);
}

function _pack(address account, bytes4 selector, uint64 period) external pure returns (bytes32) {
    bytes12 subpack = Packing.pack_4_8(selector, bytes8(period));
    return Packing.pack_20_12(bytes20(account), subpack);
}

function _unpack(bytes32 pack) external pure returns (address, bytes4, uint64) {
    return (
        address(Packing.extract_32_20(pack, 0)),
        Packing.extract_32_4(pack, 20),
        uint64(Packing.extract_32_8(pack, 24))
    );
}

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;
}

bytes32 internal constant _LOCK_SLOT = 0xf4678858b2b588224636b8522b729e7722d32fc491da849ed75b3fdf3c84f542;

function _getTransientLock() internal view returns (bool) {
    return _LOCK_SLOT.asBoolean().tload();
}

function _setTransientLock(bool lock) internal {
    _LOCK_SLOT.asBoolean().tstore(lock);
}

using SlotDerivation for bytes32;
string private constant _NAMESPACE = "<namespace>" // eg. example.main

function erc7201Pointer() internal view returns (bytes32) {
    return _NAMESPACE.erc7201Slot();
}

Unresolved include directive in modules/ROOT/pages/utilities.adoc - include::api:example$utilities/Base64NFT.sol[]

Unresolved include directive in modules/ROOT/pages/utilities.adoc - include::api:example$utilities/Multicall.sol[]

// scripts/foobar.js

const instance = await ethers.deployContract("Box");

await instance.multicall([
    instance.interface.encodeFunctionData("foo"),
    instance.interface.encodeFunctionData("bar")
]);

function processMultipleItems(uint256[] memory items) internal {
  for (uint256 i = 0; i < items.length; i++) {
    bytes memory tempData = abi.encode(items[i], block.timestamp);
    // 处理 tempData...
  }
}

function processMultipleItems(uint256[] memory items) internal {
  Memory.Pointer ptr = Memory.getFreeMemoryPointer(); // 缓存指针
  for (uint256 i = 0; i < items.length; i++) {
    bytes memory tempData = abi.encode(items[i], block.timestamp);
    // 处理 tempData...
    Memory.setFreeMemoryPointer(ptr); // 重置指针以供重用
  }
}

contract L1Inbox {
    using Blockhash for uint256;

    function verifyBlockHash(uint256 blockNumber, bytes32 expectedHash) public view returns (bool) {
        return blockNumber.blockHash() == expectedHash;
    }
}

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

import {Time} from "contracts/utils/types/Time.sol";

contract MyDelayedContract {
    using Time for *;

    Time.Delay private _delay;

    constructor() {
        _delay = Time.toDelay(3 days);
    }

    function schedule(bytes32 operationId) external {
        // 获取当前的 `_delay` 值，如果在生效前生效，则尊重任何待处理的延迟更改
        uint32 currentDelay = _delay.get();
        uint48 executionTime = Time.timestamp() + currentDelay;

        // ... 在 `executionTime` 安排操作
    }

    function execute(bytes32 operationId) external {
        uint48 executionTime = getExecutionTime(operationId);
        require(executionTime > 0, "Operation not scheduled");
        require(Time.timestamp() >= executionTime, "Delay not elapsed yet");

        // ... 执行操作
    }

    // 使用 `Time` 的安全机制更新延迟
    function updateDelay(uint32 newDelay) external {
        (Time.Delay updatedDelay, uint48 effect) = _delay.withUpdate(
            newDelay,    // 新的延迟值
            5 days       // 如果缩短延迟，则最小回退
        );

        _delay = updatedDelay;

        // ... 发出事件
    }

    // 获取完整的延迟详细信息，包括待处理的更改
    function getDelayDetails() external view returns (
        uint32 currentValue, // 当前延迟值
        uint32 pendingValue, // 待处理的延迟值
        uint48 effectTime    // 待处理的延迟更改生效的时间点
    ) {
        return _delay.getFull();
    }
}

// 来自 AccessManager.sol
function _setTargetAdminDelay(address target, uint32 newDelay) internal virtual {
    uint48 effect;
    (_targets[target].adminDelay, effect) = _targets[target].adminDelay.withUpdate(
        newDelay,
        minSetback()
    );

    emit TargetAdminDelayUpdated(target, newDelay, effect);
}