@lemmaoracle/x402 0.1.1

package/lib/forge-std/src/StdInvariant.sol

@@ -0,0 +1,161 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.13 <0.9.0;
+
+/// @notice Abstract contract providing configuration utilities for Forge invariant tests.
+abstract contract StdInvariant {
+    struct FuzzSelector {
+        address addr;
+        bytes4[] selectors;
+    }
+
+    struct FuzzArtifactSelector {
+        string artifact;
+        bytes4[] selectors;
+    }
+
+    struct FuzzInterface {
+        address addr;
+        string[] artifacts;
+    }
+
+    address[] private _excludedContracts;
+    address[] private _excludedSenders;
+    address[] private _targetedContracts;
+    address[] private _targetedSenders;
+
+    string[] private _excludedArtifacts;
+    string[] private _targetedArtifacts;
+
+    FuzzArtifactSelector[] private _targetedArtifactSelectors;
+
+    FuzzSelector[] private _excludedSelectors;
+    FuzzSelector[] private _targetedSelectors;
+
+    FuzzInterface[] private _targetedInterfaces;
+
+    // Functions for users:
+    // These are intended to be called in tests.
+
+    /// @notice Excludes a contract address from invariant target selection.
+    /// @param newExcludedContract_ The contract address to exclude.
+    function excludeContract(address newExcludedContract_) internal {
+        _excludedContracts.push(newExcludedContract_);
+    }
+
+    /// @notice Excludes specific selectors on a contract from invariant fuzzing.
+    /// @param newExcludedSelector_ The selector configuration to exclude.
+    function excludeSelector(FuzzSelector memory newExcludedSelector_) internal {
+        _excludedSelectors.push(newExcludedSelector_);
+    }
+
+    /// @notice Excludes a sender from invariant fuzzing; exclusion takes precedence over targeted senders.
+    /// @param newExcludedSender_ The sender address to exclude.
+    function excludeSender(address newExcludedSender_) internal {
+        _excludedSenders.push(newExcludedSender_);
+    }
+
+    /// @notice Excludes an artifact identifier from invariant target selection.
+    /// @param newExcludedArtifact_ The artifact identifier to exclude.
+    function excludeArtifact(string memory newExcludedArtifact_) internal {
+        _excludedArtifacts.push(newExcludedArtifact_);
+    }
+
+    /// @notice Targets an artifact identifier for invariant fuzzing.
+    /// @param newTargetedArtifact_ The artifact identifier to target.
+    function targetArtifact(string memory newTargetedArtifact_) internal {
+        _targetedArtifacts.push(newTargetedArtifact_);
+    }
+
+    /// @notice Targets specific selectors for an artifact identifier during invariant fuzzing.
+    /// @param newTargetedArtifactSelector_ The artifact-selector configuration to target.
+    function targetArtifactSelector(FuzzArtifactSelector memory newTargetedArtifactSelector_) internal {
+        _targetedArtifactSelectors.push(newTargetedArtifactSelector_);
+    }
+
+    /// @notice Targets a contract address for invariant fuzzing.
+    /// @param newTargetedContract_ The contract address to target.
+    function targetContract(address newTargetedContract_) internal {
+        _targetedContracts.push(newTargetedContract_);
+    }
+
+    /// @notice Targets specific selectors on a contract for invariant fuzzing.
+    /// @param newTargetedSelector_ The selector configuration to target.
+    function targetSelector(FuzzSelector memory newTargetedSelector_) internal {
+        _targetedSelectors.push(newTargetedSelector_);
+    }
+
+    /// @notice Adds a sender to the invariant sender allowlist; when non-empty, fuzzing uses only targeted non-excluded senders.
+    /// @param newTargetedSender_ The sender address to target.
+    function targetSender(address newTargetedSender_) internal {
+        _targetedSenders.push(newTargetedSender_);
+    }
+
+    /// @notice Targets an address plus artifact interfaces for invariant fuzzing.
+    /// @param newTargetedInterface_ The address-interface configuration to target.
+    function targetInterface(FuzzInterface memory newTargetedInterface_) internal {
+        _targetedInterfaces.push(newTargetedInterface_);
+    }
+
+    // Functions for forge:
+    // These are called by forge to run invariant tests and don't need to be called in tests.
+
+    /// @notice Returns artifact identifiers configured via `excludeArtifact`.
+    /// @return excludedArtifacts_ The list of excluded artifact identifiers.
+    function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) {
+        excludedArtifacts_ = _excludedArtifacts;
+    }
+
+    /// @notice Returns contract addresses configured via `excludeContract`.
+    /// @return excludedContracts_ The list of excluded contract addresses.
+    function excludeContracts() public view returns (address[] memory excludedContracts_) {
+        excludedContracts_ = _excludedContracts;
+    }
+
+    /// @notice Returns selector exclusions configured via `excludeSelector`.
+    /// @return excludedSelectors_ The list of excluded selector configurations.
+    function excludeSelectors() public view returns (FuzzSelector[] memory excludedSelectors_) {
+        excludedSelectors_ = _excludedSelectors;
+    }
+
+    /// @notice Returns senders configured via `excludeSender`.
+    /// @return excludedSenders_ The list of excluded sender addresses.
+    function excludeSenders() public view returns (address[] memory excludedSenders_) {
+        excludedSenders_ = _excludedSenders;
+    }
+
+    /// @notice Returns artifact identifiers configured via `targetArtifact`.
+    /// @return targetedArtifacts_ The list of targeted artifact identifiers.
+    function targetArtifacts() public view returns (string[] memory targetedArtifacts_) {
+        targetedArtifacts_ = _targetedArtifacts;
+    }
+
+    /// @notice Returns artifact-selector targets configured via `targetArtifactSelector`.
+    /// @return targetedArtifactSelectors_ The list of targeted artifact-selector configurations.
+    function targetArtifactSelectors() public view returns (FuzzArtifactSelector[] memory targetedArtifactSelectors_) {
+        targetedArtifactSelectors_ = _targetedArtifactSelectors;
+    }
+
+    /// @notice Returns contract addresses configured via `targetContract`.
+    /// @return targetedContracts_ The list of targeted contract addresses.
+    function targetContracts() public view returns (address[] memory targetedContracts_) {
+        targetedContracts_ = _targetedContracts;
+    }
+
+    /// @notice Returns selector targets configured via `targetSelector`.
+    /// @return targetedSelectors_ The list of targeted selector configurations.
+    function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) {
+        targetedSelectors_ = _targetedSelectors;
+    }
+
+    /// @notice Returns sender allowlist configured via `targetSender` (empty means no sender allowlist).
+    /// @return targetedSenders_ The list of targeted sender addresses.
+    function targetSenders() public view returns (address[] memory targetedSenders_) {
+        targetedSenders_ = _targetedSenders;
+    }
+
+    /// @notice Returns address-interface targets configured via `targetInterface`.
+    /// @return targetedInterfaces_ The list of targeted address-interface configurations.
+    function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) {
+        targetedInterfaces_ = _targetedInterfaces;
+    }
+}

package/lib/forge-std/src/StdJson.sol

@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.13 <0.9.0;
+
+import {VmSafe} from "./Vm.sol";
+
+// Helpers for parsing and writing JSON files
+// To parse:
+// ```
+// using stdJson for string;
+// string memory json = vm.readFile("<some_path>");
+// json.readUint("<json_path>");
+// ```
+// To write:
+// ```
+// using stdJson for string;
+// string memory json = "json";
+// json.serialize("a", uint256(123));
+// string memory semiFinal = json.serialize("b", string("test"));
+// string memory finalJson = json.serialize("c", semiFinal);
+// finalJson.write("<some_path>");
+// ```
+
+library stdJson {
+    VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
+
+    function keyExists(string memory json, string memory key) internal view returns (bool) {
+        return vm.keyExistsJson(json, key);
+    }
+
+    function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {
+        return vm.parseJson(json, key);
+    }
+
+    function readUint(string memory json, string memory key) internal pure returns (uint256) {
+        return vm.parseJsonUint(json, key);
+    }
+
+    function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {
+        return vm.parseJsonUintArray(json, key);
+    }
+
+    function readInt(string memory json, string memory key) internal pure returns (int256) {
+        return vm.parseJsonInt(json, key);
+    }
+
+    function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {
+        return vm.parseJsonIntArray(json, key);
+    }
+
+    function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {
+        return vm.parseJsonBytes32(json, key);
+    }
+
+    function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {
+        return vm.parseJsonBytes32Array(json, key);
+    }
+
+    function readString(string memory json, string memory key) internal pure returns (string memory) {
+        return vm.parseJsonString(json, key);
+    }
+
+    function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {
+        return vm.parseJsonStringArray(json, key);
+    }
+
+    function readAddress(string memory json, string memory key) internal pure returns (address) {
+        return vm.parseJsonAddress(json, key);
+    }
+
+    function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {
+        return vm.parseJsonAddressArray(json, key);
+    }
+
+    function readBool(string memory json, string memory key) internal pure returns (bool) {
+        return vm.parseJsonBool(json, key);
+    }
+
+    function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {
+        return vm.parseJsonBoolArray(json, key);
+    }
+
+    function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {
+        return vm.parseJsonBytes(json, key);
+    }
+
+    function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {
+        return vm.parseJsonBytesArray(json, key);
+    }
+
+    function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {
+        return keyExists(json, key) ? readUint(json, key) : defaultValue;
+    }
+
+    function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)
+        internal
+        view
+        returns (uint256[] memory)
+    {
+        return keyExists(json, key) ? readUintArray(json, key) : defaultValue;
+    }
+
+    function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {
+        return keyExists(json, key) ? readInt(json, key) : defaultValue;
+    }
+
+    function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)
+        internal
+        view
+        returns (int256[] memory)
+    {
+        return keyExists(json, key) ? readIntArray(json, key) : defaultValue;
+    }
+
+    function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)
+        internal
+        view
+        returns (bytes32)
+    {
+        return keyExists(json, key) ? readBytes32(json, key) : defaultValue;
+    }
+
+    function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)
+        internal
+        view
+        returns (bytes32[] memory)
+    {
+        return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;
+    }
+
+    function readStringOr(string memory json, string memory key, string memory defaultValue)
+        internal
+        view
+        returns (string memory)
+    {
+        return keyExists(json, key) ? readString(json, key) : defaultValue;
+    }
+
+    function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)
+        internal
+        view
+        returns (string[] memory)
+    {
+        return keyExists(json, key) ? readStringArray(json, key) : defaultValue;
+    }
+
+    function readAddressOr(string memory json, string memory key, address defaultValue)
+        internal
+        view
+        returns (address)
+    {
+        return keyExists(json, key) ? readAddress(json, key) : defaultValue;
+    }
+
+    function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)
+        internal
+        view
+        returns (address[] memory)
+    {
+        return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;
+    }
+
+    function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {
+        return keyExists(json, key) ? readBool(json, key) : defaultValue;
+    }
+
+    function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)
+        internal
+        view
+        returns (bool[] memory)
+    {
+        return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;
+    }
+
+    function readBytesOr(string memory json, string memory key, bytes memory defaultValue)
+        internal
+        view
+        returns (bytes memory)
+    {
+        return keyExists(json, key) ? readBytes(json, key) : defaultValue;
+    }
+
+    function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)
+        internal
+        view
+        returns (bytes[] memory)
+    {
+        return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;
+    }
+
+    function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
+        return vm.serializeJson(jsonKey, rootObject);
+    }
+
+    function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
+        return vm.serializeBool(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory) {
+        return vm.serializeBool(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
+        return vm.serializeUint(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, uint256[] memory value)
+        internal
+        returns (string memory)
+    {
+        return vm.serializeUint(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
+        return vm.serializeInt(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, int256[] memory value)
+        internal
+        returns (string memory)
+    {
+        return vm.serializeInt(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
+        return vm.serializeAddress(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, address[] memory value)
+        internal
+        returns (string memory)
+    {
+        return vm.serializeAddress(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
+        return vm.serializeBytes32(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
+        internal
+        returns (string memory)
+    {
+        return vm.serializeBytes32(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
+        return vm.serializeBytes(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, bytes[] memory value)
+        internal
+        returns (string memory)
+    {
+        return vm.serializeBytes(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory) {
+        return vm.serializeString(jsonKey, key, value);
+    }
+
+    function serialize(string memory jsonKey, string memory key, string[] memory value)
+        internal
+        returns (string memory)
+    {
+        return vm.serializeString(jsonKey, key, value);
+    }
+
+    function write(string memory jsonKey, string memory path) internal {
+        vm.writeJson(jsonKey, path);
+    }
+
+    function write(string memory jsonKey, string memory path, string memory valueKey) internal {
+        vm.writeJson(jsonKey, path, valueKey);
+    }
+}

package/lib/forge-std/src/StdMath.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.13 <0.9.0;
+
+library stdMath {
+    int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;
+
+    function abs(int256 a) internal pure returns (uint256) {
+        // Required or it will fail when `a = type(int256).min`
+        if (a == INT256_MIN) {
+            return 57896044618658097711785492504343953926634992332820282019728792003956564819968;
+        }
+
+        return uint256(a > 0 ? a : -a);
+    }
+
+    function delta(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a > b ? a - b : b - a;
+    }
+
+    function delta(int256 a, int256 b) internal pure returns (uint256) {
+        // a and b are of the same sign
+        // this works thanks to two's complement, the left-most bit is the sign bit
+        if ((a ^ b) > -1) {
+            return delta(abs(a), abs(b));
+        }
+
+        // a and b are of opposite signs
+        return abs(a) + abs(b);
+    }
+
+    function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {
+        // Prevent division by zero
+        require(b != 0, "stdMath percentDelta(uint256,uint256): Divisor is zero");
+        uint256 absDelta = delta(a, b);
+
+        return absDelta * 1e18 / b;
+    }
+
+    function percentDelta(int256 a, int256 b) internal pure returns (uint256) {
+        uint256 absDelta = delta(a, b);
+        uint256 absB = abs(b);
+        // Prevent division by zero
+        require(absB != 0, "stdMath percentDelta(int256,int256): Divisor is zero");
+
+        return absDelta * 1e18 / absB;
+    }
+}