@1inch/solidity-utils 3.8.3 → 4.1.0

package/contracts/libraries/ECDSA.sol

@@ -4,6 +4,10 @@ pragma solidity ^0.8.0;
 
 import "@openzeppelin/contracts/interfaces/IERC1271.sol";
 
+/**
+ * @title ECDSA signature operations
+ * @notice Provides functions for recovering addresses from signatures and verifying signatures, including support for EIP-2098 compact signatures.
+ */
 library ECDSA {
     // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
     // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
@@ -18,6 +22,15 @@ library ECDSA {
     uint256 private constant _COMPACT_S_MASK = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
     uint256 private constant _COMPACT_V_SHIFT = 255;
 
+    /**
+     * @notice Recovers the signer's address from the signature.
+     * @dev Recovers the address that has signed a hash with `(v, r, s)` signature.
+     * @param hash The keccak256 hash of the data signed.
+     * @param v The recovery byte of the signature.
+     * @param r The first 32 bytes of the signature.
+     * @param s The second 32 bytes of the signature.
+     * @return signer The address of the signer.
+     */
     function recover(
         bytes32 hash,
         uint8 v,
@@ -39,6 +52,14 @@ library ECDSA {
         }
     }
 
+    /**
+     * @notice Recovers the signer's address from the signature using `r` and `vs` components.
+     * @dev Recovers the address that has signed a hash with `r` and `vs`, where `vs` combines `v` and `s`.
+     * @param hash The keccak256 hash of the data signed.
+     * @param r The first 32 bytes of the signature.
+     * @param vs The combined `v` and `s` values of the signature.
+     * @return signer The address of the signer.
+     */
     function recover(
         bytes32 hash,
         bytes32 r,
@@ -60,6 +81,12 @@ library ECDSA {
         }
     }
 
+    /**
+     * @notice Recovers the signer's address from a hash and a signature.
+     * @param hash The keccak256 hash of the signed data.
+     * @param signature The full signature from which the signer will be recovered.
+     * @return signer The address of the signer.
+     */
     /// @dev WARNING!!!
     /// There is a known signature malleability issue with two representations of signatures!
     /// Even though this function is able to verify both standard 65-byte and compact 64-byte EIP-2098 signatures
@@ -102,6 +129,14 @@ library ECDSA {
         }
     }
 
+    /**
+     * @notice Verifies the signature for a hash, either by recovering the signer or using EIP-1271's `isValidSignature` function.
+     * @dev Attempts to recover the signer's address from the signature; if the address is non-zero, checks if it's valid according to EIP-1271.
+     * @param signer The address to validate the signature against.
+     * @param hash The hash of the signed data.
+     * @param signature The signature to verify.
+     * @return success True if the signature is verified, false otherwise.
+     */
     function recoverOrIsValidSignature(
         address signer,
         bytes32 hash,
@@ -114,6 +149,16 @@ library ECDSA {
         return isValidSignature(signer, hash, signature);
     }
 
+    /**
+     * @notice Verifies the signature for a hash, either by recovering the signer or using EIP-1271's `isValidSignature` function.
+     * @dev Attempts to recover the signer's address from the signature; if the address is non-zero, checks if it's valid according to EIP-1271.
+     * @param signer The address to validate the signature against.
+     * @param hash The hash of the signed data.
+     * @param v The recovery byte of the signature.
+     * @param r The first 32 bytes of the signature.
+     * @param s The second 32 bytes of the signature.
+     * @return success True if the signature is verified, false otherwise.
+     */
     function recoverOrIsValidSignature(
         address signer,
         bytes32 hash,
@@ -128,6 +173,15 @@ library ECDSA {
         return isValidSignature(signer, hash, v, r, s);
     }
 
+    /**
+     * @notice Verifies the signature for a hash, either by recovering the signer or using EIP-1271's `isValidSignature` function.
+     * @dev Attempts to recover the signer's address from the signature; if the address is non-zero, checks if it's valid according to EIP-1271.
+     * @param signer The address to validate the signature against.
+     * @param hash The hash of the signed data.
+     * @param r The first 32 bytes of the signature.
+     * @param vs The combined `v` and `s` values of the signature.
+     * @return success True if the signature is verified, false otherwise.
+     */
     function recoverOrIsValidSignature(
         address signer,
         bytes32 hash,
@@ -141,6 +195,15 @@ library ECDSA {
         return isValidSignature(signer, hash, r, vs);
     }
 
+    /**
+     * @notice Verifies the signature for a given hash, attempting to recover the signer's address or validates it using EIP-1271 for 65-byte signatures.
+     * @dev Attempts to recover the signer's address from the signature. If the address is a contract, checks if the signature is valid according to EIP-1271.
+     * @param signer The expected signer's address.
+     * @param hash The keccak256 hash of the signed data.
+     * @param r The first 32 bytes of the signature.
+     * @param vs The last 32 bytes of the signature, with the last byte being the recovery id.
+     * @return success True if the signature is valid, false otherwise.
+     */
     function recoverOrIsValidSignature65(
         address signer,
         bytes32 hash,
@@ -154,6 +217,14 @@ library ECDSA {
         return isValidSignature65(signer, hash, r, vs);
     }
 
+    /**
+     * @notice Validates a signature for a hash using EIP-1271, if `signer` is a contract.
+     * @dev Makes a static call to `signer` with `isValidSignature` function selector from EIP-1271.
+     * @param signer The address of the signer to validate against, which could be an EOA or a contract.
+     * @param hash The hash of the signed data.
+     * @param signature The signature to validate.
+     * @return success True if the signature is valid according to EIP-1271, false otherwise.
+     */
     function isValidSignature(
         address signer,
         bytes32 hash,
@@ -176,6 +247,16 @@ library ECDSA {
         }
     }
 
+    /**
+     * @notice Validates a signature for a hash using EIP-1271, if `signer` is a contract.
+     * @dev Makes a static call to `signer` with `isValidSignature` function selector from EIP-1271.
+     * @param signer The address of the signer to validate against, which could be an EOA or a contract.
+     * @param hash The hash of the signed data.
+     * @param v The recovery byte of the signature.
+     * @param r The first 32 bytes of the signature.
+     * @param s The second 32 bytes of the signature.
+     * @return success True if the signature is valid according to EIP-1271, false otherwise.
+     */
     function isValidSignature(
         address signer,
         bytes32 hash,
@@ -200,6 +281,15 @@ library ECDSA {
         }
     }
 
+    /**
+     * @notice Validates a signature for a hash using EIP-1271, if `signer` is a contract.
+     * @dev Makes a static call to `signer` with `isValidSignature` function selector from EIP-1271.
+     * @param signer The address of the signer to validate against, which could be an EOA or a contract.
+     * @param hash The hash of the signed data.
+     * @param r The first 32 bytes of the signature.
+     * @param vs The last 32 bytes of the signature, with the last byte being the recovery id.
+     * @return success True if the signature is valid according to EIP-1271, false otherwise.
+     */
     function isValidSignature(
         address signer,
         bytes32 hash,
@@ -224,6 +314,14 @@ library ECDSA {
         }
     }
 
+    /**
+     * @notice Verifies if a 65-byte signature is valid for a given hash, according to EIP-1271.
+     * @param signer The address of the signer to validate against, which could be an EOA or a contract.
+     * @param hash The hash of the signed data.
+     * @param r The first 32 bytes of the signature.
+     * @param vs The combined `v` (recovery id) and `s` component of the signature, packed into the last 32 bytes.
+     * @return success True if the signature is valid according to EIP-1271, false otherwise.
+     */
     function isValidSignature65(
         address signer,
         bytes32 hash,
@@ -249,6 +347,12 @@ library ECDSA {
         }
     }
 
+    /**
+     * @notice Generates a hash compatible with Ethereum's signed message format.
+     * @dev Prepends the hash with Ethereum's message prefix before hashing it.
+     * @param hash The hash of the data to sign.
+     * @return res The Ethereum signed message hash.
+     */
     function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 res) {
         // 32 is the length in bytes of hash, enforced by the type signature above
         // return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
@@ -259,6 +363,13 @@ library ECDSA {
         }
     }
 
+    /**
+     * @notice Generates an EIP-712 compliant hash.
+     * @dev Encodes the domain separator and the struct hash according to EIP-712.
+     * @param domainSeparator The EIP-712 domain separator.
+     * @param structHash The EIP-712 struct hash.
+     * @return res The EIP-712 compliant hash.
+     */
     function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 res) {
         // return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
         assembly ("memory-safe") { // solhint-disable-line no-inline-assembly

package/contracts/libraries/RevertReasonForwarder.sol

@@ -2,9 +2,15 @@
 
 pragma solidity ^0.8.0;
 
-/// @title Revert reason forwarder.
+/**
+ * @title RevertReasonForwarder
+ * @notice Provides utilities for forwarding and retrieving revert reasons from failed external calls.
+ */
 library RevertReasonForwarder {
-    /// @dev Forwards latest externall call revert.
+    /**
+     * @dev Forwards the revert reason from the latest external call.
+     * This method allows propagating the revert reason of a failed external call to the caller.
+     */
     function reRevert() internal pure {
         // bubble up revert reason from latest external call
         assembly ("memory-safe") { // solhint-disable-line no-inline-assembly
@@ -14,7 +20,11 @@ library RevertReasonForwarder {
         }
     }
 
-    /// @dev Returns latest external call revert reason.
+    /**
+     * @dev Retrieves the revert reason from the latest external call.
+     * This method enables capturing the revert reason of a failed external call for inspection or processing.
+     * @return reason The latest external call revert reason.
+     */
     function reReason() internal pure returns (bytes memory reason) {
         assembly ("memory-safe") { // solhint-disable-line no-inline-assembly
             reason := mload(0x40)

package/contracts/libraries/RevertReasonParser.sol

@@ -4,7 +4,9 @@ pragma solidity ^0.8.0;
 
 import "./StringUtil.sol";
 
-/** @title Library that allows to parse unsuccessful arbitrary calls revert reasons.
+/**
+ * @title RevertReasonParser
+ * @notice Library that allows to parse unsuccessful arbitrary calls revert reasons.
  * See https://solidity.readthedocs.io/en/latest/control-structures.html#revert for details.
  * Note that we assume revert reason being abi-encoded as Error(string) so it may fail to parse reason
  * if structured reverts appear in the future.
@@ -20,7 +22,14 @@ library RevertReasonParser {
     bytes4 private constant _ERROR_SELECTOR = bytes4(keccak256("Error(string)"));
     bytes4 private constant _PANIC_SELECTOR = bytes4(keccak256("Panic(uint256)"));
 
-    /// @dev Parses error `data` and returns actual with `prefix`.
+    /**
+     * @dev Parses revert reason from failed calls, returning it with a `prefix`.
+     * Handles standard `Error(string)` and `Panic(uint256)` formats, defaulting to `Unknown(data)` for unrecognized patterns.
+     *
+     * @param data The revert data to parse.
+     * @param prefix String to add before the parsed reason for context.
+     * @return The formatted revert reason.
+     */
     function parse(bytes memory data, string memory prefix) internal pure returns (string memory) {
         // https://solidity.readthedocs.io/en/latest/control-structures.html#revert
         // We assume that revert reason is abi-encoded as Error(string)

package/contracts/libraries/SafeERC20.sol

@@ -6,6 +6,7 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
 import "../interfaces/IDaiLikePermit.sol";
 import "../interfaces/IPermit2.sol";
+import "../interfaces/IERC7597Permit.sol";
 import "../interfaces/IWETH.sol";
 import "../libraries/RevertReasonForwarder.sol";
 
@@ -301,6 +302,7 @@ library SafeERC20 {
         bytes4 permitSelector = IERC20Permit.permit.selector;
         bytes4 daiPermitSelector = IDaiLikePermit.permit.selector;
         bytes4 permit2Selector = IPermit2.permit.selector;
+        bytes4 erc7597PermitSelector = IERC7597Permit.permit.selector;
         assembly ("memory-safe") { // solhint-disable-line no-inline-assembly
             let ptr := mload(0x40)
 
@@ -389,10 +391,12 @@ library SafeERC20 {
                 // IPermit2.permit(address owner, PermitSingle calldata permitSingle, bytes calldata signature)
                 success := call(gas(), _PERMIT2, 0, ptr, 0x164, 0, 0)
             }
-            // Unknown
+            // Dynamic length
             default {
-                mstore(ptr, _PERMIT_LENGTH_ERROR)
-                revert(ptr, 4)
+                mstore(ptr, erc7597PermitSelector)
+                calldatacopy(add(ptr, 0x04), permit.offset, permit.length) // copy permit calldata
+                // IERC7597Permit.permit(address owner, address spender, uint256 value, uint256 deadline, bytes memory signature)
+                success := call(gas(), token, 0, ptr, add(permit.length, 4), 0, 0)
             }
         }
     }

package/contracts/libraries/StringUtil.sol

@@ -2,18 +2,36 @@
 
 pragma solidity ^0.8.0;
 
-/// @title Library with gas-efficient string operations
+/**
+ * @title StringUtil
+ * @dev Library with gas-efficient string operations.
+ */
 library StringUtil {
+    /**
+     * @notice Converts a uint256 value to its hexadecimal string representation.
+     * @param value The uint256 value to convert.
+     * @return The hexadecimal string representation of the input value.
+     */
     function toHex(uint256 value) internal pure returns (string memory) {
         return toHex(abi.encodePacked(value));
     }
 
+    /**
+     * @notice Converts an address to its hexadecimal string representation.
+     * @param value The address to convert.
+     * @return The hexadecimal string representation of the input address.
+     */
     function toHex(address value) internal pure returns (string memory) {
         return toHex(abi.encodePacked(value));
     }
 
-    /// @dev this is the assembly adaptation of highly optimized toHex16 code from Mikhail Vladimirov
-    /// https://stackoverflow.com/a/69266989
+    /**
+     * @dev Converts arbitrary bytes to their hexadecimal string representation.
+     * This is an assembly adaptation of highly optimized toHex16 code by Mikhail Vladimirov.
+     * Reference: https://stackoverflow.com/a/69266989
+     * @param data The bytes to be converted to hexadecimal string.
+     * @return result The hexadecimal string representation of the input bytes.
+     */
     function toHex(bytes memory data) internal pure returns (string memory result) {
         assembly ("memory-safe") { // solhint-disable-line no-inline-assembly
             function _toHex16(input) -> output {

package/contracts/libraries/UniERC20.sol

@@ -8,7 +8,11 @@ import "../interfaces/IERC20MetadataUppercase.sol";
 import "./SafeERC20.sol";
 import "./StringUtil.sol";
 
-/// @title Library, which allows usage of ETH as ERC20 and ERC20 itself. Uses SafeERC20 library for ERC20 interface.
+/**
+ * @title UniERC20
+ * @dev Library to abstract the handling of ETH and ERC20 tokens, enabling unified interaction with both. It allows usage of ETH as ERC20.
+ * Utilizes SafeERC20 for ERC20 interactions and provides additional utility functions.
+ */
 library UniERC20 {
     using SafeERC20 for IERC20;
 
@@ -23,12 +27,21 @@ library UniERC20 {
     IERC20 private constant _ETH_ADDRESS = IERC20(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
     IERC20 private constant _ZERO_ADDRESS = IERC20(address(0));
 
-    /// @dev Returns true if `token` is ETH.
+    /**
+     * @dev Determines if the specified token is ETH.
+     * @param token The token to check.
+     * @return bool True if the token is ETH, false otherwise.
+     */
     function isETH(IERC20 token) internal pure returns (bool) {
         return (token == _ZERO_ADDRESS || token == _ETH_ADDRESS);
     }
 
-    /// @dev Returns `account` ERC20 `token` balance.
+    /**
+     * @dev Retrieves the balance of the specified token for an account.
+     * @param token The token to query the balance of.
+     * @param account The address of the account.
+     * @return uint256 The balance of the token for the specified account.
+     */
     function uniBalanceOf(IERC20 token, address account) internal view returns (uint256) {
         if (isETH(token)) {
             return account.balance;
@@ -37,8 +50,13 @@ library UniERC20 {
         }
     }
 
-    /// @dev `token` transfer `to` `amount`.
-    /// Note that this function does nothing in case of zero amount.
+    /**
+     * @dev Transfers a specified amount of the token to a given address.
+     * Note: Does nothing if the amount is zero.
+     * @param token The token to transfer.
+     * @param to The address to transfer the token to.
+     * @param amount The amount of the token to transfer.
+     */
     function uniTransfer(
         IERC20 token,
         address payable to,
@@ -56,8 +74,14 @@ library UniERC20 {
         }
     }
 
-    /// @dev `token` transfer `from` `to` `amount`.
-    /// Note that this function does nothing in case of zero amount.
+    /**
+     * @dev Transfers a specified amount of the token from one address to another.
+     * Note: Does nothing if the amount is zero.
+     * @param token The token to transfer.
+     * @param from The address to transfer the token from.
+     * @param to The address to transfer the token to.
+     * @param amount The amount of the token to transfer.
+     */
     function uniTransferFrom(
         IERC20 token,
         address payable from,
@@ -83,17 +107,31 @@ library UniERC20 {
         }
     }
 
-    /// @dev Returns `token` symbol from ERC20 metadata.
+    /**
+     * @dev Retrieves the symbol from ERC20 metadata of the specified token.
+     * @param token The token to retrieve the symbol of.
+     * @return string The symbol of the token.
+     */
     function uniSymbol(IERC20 token) internal view returns (string memory) {
         return _uniDecode(token, IERC20Metadata.symbol.selector, IERC20MetadataUppercase.SYMBOL.selector);
     }
 
-    /// @dev Returns `token` name from ERC20 metadata.
+    /**
+     * @dev Retrieves the name from ERC20 metadata of the specified token.
+     * @param token The token to retrieve the name of.
+     * @return string The name of the token.
+     */
     function uniName(IERC20 token) internal view returns (string memory) {
         return _uniDecode(token, IERC20Metadata.name.selector, IERC20MetadataUppercase.NAME.selector);
     }
 
-    /// @dev Reverts if `token` is ETH, otherwise performs ERC20 forceApprove.
+    /**
+     * @dev forceApprove the specified amount of the token to a given address.
+     * Reverts if the token is ETH.
+     * @param token The token to approve.
+     * @param to The address to approve the token to.
+     * @param amount The amount of the token to approve.
+     */
     function uniApprove(
         IERC20 token,
         address to,
@@ -104,8 +142,15 @@ library UniERC20 {
         token.forceApprove(to, amount);
     }
 
-    /// @dev 20K gas is provided to account for possible implementations of name/symbol
-    /// (token implementation might be behind proxy or store the value in storage)
+    /**
+     * @dev Internal function to decode token metadata (name or symbol).
+     * 20K gas is provided to account for possible implementations of name/symbol
+     * (token implementation might be behind proxy or store the value in storage)
+     * @param token The token to decode metadata for.
+     * @param lowerCaseSelector The selector for the lowercase metadata function.
+     * @param upperCaseSelector The selector for the uppercase metadata function.
+     * @return result The decoded metadata value.
+     */
     function _uniDecode(
         IERC20 token,
         bytes4 lowerCaseSelector,

package/contracts/mocks/ERC20PermitMock.sol

@@ -5,7 +5,19 @@ pragma solidity ^0.8.0;
 import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
 import "./TokenMock.sol";
 
+/**
+ * @title ERC20PermitMock
+ * @dev Extends ERC20Permit and TokenMock for testing purposes, incorporating permit functionality.
+ * This contract simplifies the testing of ERC20 tokens with permit capabilities by allowing easy setup of initial states.
+ */
 contract ERC20PermitMock is ERC20Permit, TokenMock {
+    /**
+     * @dev Creates an instance of `ERC20PermitMock` with specified token details and initial token distribution.
+     * @param name Name of the ERC20 token.
+     * @param symbol Symbol of the ERC20 token.
+     * @param initialAccount Address to receive the initial token supply.
+     * @param initialBalance Amount of tokens to mint to the `initialAccount`.
+     */
     constructor(
         string memory name,
         string memory symbol,

package/contracts/mocks/SelfdestructEthSenderMock.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.25;
+
+import "../mixins/SelfdestructEthSender.sol";
+
+contract SelfdestructEthSenderMock is SelfdestructEthSender {
+    error ETHTransferFailed();
+
+    receive() external payable {}
+
+    function transferBalance(address payable receiver) external payable {
+        // solhint-disable-next-line avoid-low-level-calls
+        (bool success, ) = receiver.call{value: address(this).balance}("");
+        if (!success) revert ETHTransferFailed();
+    }
+}

package/contracts/mocks/TokenCustomDecimalsMock.sol

@@ -5,9 +5,20 @@ pragma solidity ^0.8.0;
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
 
+/**
+ * @title TokenCustomDecimalsMock
+ * @dev Extends ERC20Permit token with custom number of decimals and only owner access to `mint` and `burn` functionality.
+ */
 contract TokenCustomDecimalsMock is ERC20Permit, Ownable {
     uint8 internal immutable _DECIMALS;
 
+    /**
+     * @dev Sets up the ERC20 token with a name, symbol, initial amount to mint, and custom decimals.
+     * @param name Name of the token.
+     * @param symbol Symbol of the token.
+     * @param amount Initial amount of tokens to mint to the owner.
+     * @param decimals_ Custom number of decimal places for the token.
+     */
     constructor(
         string memory name,
         string memory symbol,
@@ -18,19 +29,29 @@ contract TokenCustomDecimalsMock is ERC20Permit, Ownable {
         _DECIMALS = decimals_;
     }
 
+    /**
+     * @notice Mints tokens to a specified account, callable only by the owner.
+     * @param account The address to mint tokens to.
+     * @param amount The amount of tokens to mint.
+     */
     function mint(address account, uint256 amount) external onlyOwner {
         _mint(account, amount);
     }
 
+    /**
+     * @notice Burns tokens from a specified account, callable only by the owner.
+     * @param account The address to burn tokens from.
+     * @param amount The amount of tokens to burn.
+     */
     function burn(address account, uint256 amount) external onlyOwner {
         _burn(account, amount);
     }
 
+    /**
+     * @dev Returns the number of decimal places of the token.
+     * @return Number of decimal places.
+     */
     function decimals() public view virtual override returns (uint8) {
         return _DECIMALS;
     }
-
-    function getChainId() external view returns (uint256) {
-        return block.chainid;
-    }
 }

package/contracts/mocks/TokenMock.sol

@@ -5,14 +5,33 @@ pragma solidity ^0.8.0;
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
+/**
+ * @title TokenMock
+ * @dev Simple ERC20 token mock for testing purposes, with minting and burning capabilities restricted to the owner.
+ */
 contract TokenMock is ERC20, Ownable {
+    /**
+     * @dev Initializes the contract with token name and symbol, setting the deployer as the owner.
+     * @param name Name of the ERC20 token.
+     * @param symbol Symbol of the ERC20 token.
+     */
     // solhint-disable-next-line no-empty-blocks
     constructor(string memory name, string memory symbol) ERC20(name, symbol) Ownable(msg.sender) {}
 
+    /**
+     * @notice Mints tokens to a specified account, callable only by the owner.
+     * @param account The address to mint tokens to.
+     * @param amount The amount of tokens to mint.
+     */
     function mint(address account, uint256 amount) external onlyOwner {
         _mint(account, amount);
     }
 
+    /**
+     * @notice Burns tokens from a specified account, callable only by the owner.
+     * @param account The address to burn tokens from.
+     * @param amount The amount of tokens to burn.
+     */
     function burn(address account, uint256 amount) external onlyOwner {
         _burn(account, amount);
     }

package/dist/hardhat-setup/networks.d.ts

@@ -1,17 +1,40 @@
 import { ChainConfig } from '@nomicfoundation/hardhat-verify/src/types';
 import { Network, NetworksUserConfig } from 'hardhat/types';
+/** @internal */
 export type Etherscan = {
     apiKey: {
         [key: string]: string;
     };
     customChains: ChainConfig[];
 };
+/**
+ * @category Hardhat-Setup
+ * @notice A helper method to get the network name from the command line arguments.
+ * @returns The network name.
+ */
 export declare function getNetwork(): string;
+/**
+ * @category Hardhat-Setup
+ * @notice A helper method to parse RPC configuration strings. Checks that the string is in the expected format.
+ * @param envRpc The RPC configuration string to parse.
+ * @returns An object containing the RPC URL and optional auth key HTTP header.
+ */
 export declare function parseRpcEnv(envRpc: string): {
     url: string;
     authKeyHttpHeader?: string;
 };
+/**
+ * @category Hardhat-Setup
+ * @notice A helper method to reset the Hardhat network to the local network or to a fork.
+ * @param network The Hardhat network object.
+ * @param networkName The name of the network to reset to.
+ */
 export declare function resetHardhatNetworkFork(network: Network, networkName: string): Promise<void>;
+/**
+ * @category Hardhat-Setup
+ * @notice The Network class is a helper class to register networks and Etherscan API keys.
+ * See the [README](https://github.com/1inch/solidity-utils/tree/master/hardhat-setup/README.md) for usage.
+ */
 export declare class Networks {
     networks: NetworksUserConfig;
     etherscan: Etherscan;

package/dist/hardhat-setup/networks.js

@@ -3,11 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Networks = exports.resetHardhatNetworkFork = exports.parseRpcEnv = exports.getNetwork = void 0;
 const tslib_1 = require("tslib");
 const dotenv_1 = tslib_1.__importDefault(require("dotenv"));
+/**
+ * @category Hardhat-Setup
+ * @notice A helper method to get the network name from the command line arguments.
+ * @returns The network name.
+ */
 function getNetwork() {
     const index = process.argv.findIndex((arg) => arg === '--network') + 1;
     return index !== 0 ? process.argv[index] : 'unknown';
 }
 exports.getNetwork = getNetwork;
+/**
+ * @category Hardhat-Setup
+ * @notice A helper method to parse RPC configuration strings. Checks that the string is in the expected format.
+ * @param envRpc The RPC configuration string to parse.
+ * @returns An object containing the RPC URL and optional auth key HTTP header.
+ */
 function parseRpcEnv(envRpc) {
     const [url, authKeyHttpHeader, overflow] = envRpc.split('|');
     if (overflow || url === '') {
@@ -16,6 +27,12 @@ function parseRpcEnv(envRpc) {
     return { url, authKeyHttpHeader };
 }
 exports.parseRpcEnv = parseRpcEnv;
+/**
+ * @category Hardhat-Setup
+ * @notice A helper method to reset the Hardhat network to the local network or to a fork.
+ * @param network The Hardhat network object.
+ * @param networkName The name of the network to reset to.
+ */
 async function resetHardhatNetworkFork(network, networkName) {
     if (networkName.toLowerCase() === 'hardhat') {
         await network.provider.request({
@@ -37,6 +54,11 @@ async function resetHardhatNetworkFork(network, networkName) {
     }
 }
 exports.resetHardhatNetworkFork = resetHardhatNetworkFork;
+/**
+ * @category Hardhat-Setup
+ * @notice The Network class is a helper class to register networks and Etherscan API keys.
+ * See the [README](https://github.com/1inch/solidity-utils/tree/master/hardhat-setup/README.md) for usage.
+ */
 class Networks {
     constructor(useHardhat = true, forkingNetworkName, saveHardhatDeployments = false) {
         this.networks = {};