Replacement for Solidity's transfer: sends amount wei to recipient, forwarding all available gas and reverting on errors.

EIP1884 increases the gas cost of certain opcodes, possibly making contracts go over the 2300 gas limit imposed by transfer, making them unable to receive funds via transfer. Address.sendValue removes this limitation.

Learn more.

taken to not create reentrancy vulnerabilities. Consider using ReentrancyGuard or the checks-effects-interactions pattern.

Performs a Solidity function call using a low level call. A plain call is an unsafe replacement for a function call: use this function instead.

If target reverts with a revert reason or custom error, it is bubbled up by this function (like regular Solidity function calls). However, if the call reverted with no returned reason, this function reverts with a Errors.FailedCall error.

Returns the raw returned data. To convert to the expected return value, use abi.decode.

Requirements:

• target must be a contract.
• calling target with data must not revert.

Same as functionCall, but also transferring value wei to target.

Requirements:

• the calling contract must have an ETH balance of at least value.
• the called Solidity function must be payable.

Same as functionCall, but performing a static call.

Same as functionCall, but performing a delegate call.

Tool to verify that a low level call to smart-contract was successful, and reverts if the target was not a contract or bubbling up the revert reason (falling back to Errors.FailedCall) in case of an unsuccessful call.

Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the revert reason or with a default Errors.FailedCall error.

There's no code at target (it is not a contract).

Sort an array of uint256 (in memory) following the provided comparator function.

This function does the sorting "in place", meaning that it overrides the input. The object is returned for convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.

NOTE: this function's cost is O(n · log(n)) in average and O(n²) in the worst case, with n the length of the array. Using it in view functions that are executed through eth_call is safe, but one should be very careful when executing this as part of a transaction. If the array being sorted is too large, the sort operation may consume more gas than is available in a block, leading to potential DoS.

Variant of Arrays.sort that sorts an array of uint256 in increasing order.

Sort an array of address (in memory) following the provided comparator function.

This function does the sorting "in place", meaning that it overrides the input. The object is returned for convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.

NOTE: this function's cost is O(n · log(n)) in average and O(n²) in the worst case, with n the length of the array. Using it in view functions that are executed through eth_call is safe, but one should be very careful when executing this as part of a transaction. If the array being sorted is too large, the sort operation may consume more gas than is available in a block, leading to potential DoS.

Variant of Arrays.sort that sorts an array of address in increasing order.

Sort an array of bytes32 (in memory) following the provided comparator function.

This function does the sorting "in place", meaning that it overrides the input. The object is returned for convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array.

NOTE: this function's cost is O(n · log(n)) in average and O(n²) in the worst case, with n the length of the array. Using it in view functions that are executed through eth_call is safe, but one should be very careful when executing this as part of a transaction. If the array being sorted is too large, the sort operation may consume more gas than is available in a block, leading to potential DoS.

Variant of Arrays.sort that sorts an array of bytes32 in increasing order.

Searches a sorted array and returns the first index that contains a value greater or equal to element. If no such index exists (i.e. all values in the array are strictly less than element), the array length is returned. Time complexity O(log n).

NOTE: The array is expected to be sorted in ascending order, and to contain no repeated elements.

support for repeated elements in the array. The Arrays.lowerBound function should be used instead.

Searches an array sorted in ascending order and returns the first index that contains a value greater or equal than element. If no such index exists (i.e. all values in the array are strictly less than element), the array length is returned. Time complexity O(log n).

See C++'s lower_bound.

Searches an array sorted in ascending order and returns the first index that contains a value strictly greater than element. If no such index exists (i.e. all values in the array are strictly less than element), the array length is returned. Time complexity O(log n).

See C++'s upper_bound.

Same as Arrays.lowerBound, but with an array in memory.

Same as Arrays.upperBound, but with an array in memory.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.

Helper to set the length of a dynamic array. Directly writing to .length is forbidden.

Helper to set the length of a dynamic array. Directly writing to .length is forbidden.

Helper to set the length of a dynamic array. Directly writing to .length is forbidden.

Helper to set the length of a dynamic array. Directly writing to .length is forbidden.

Helper to set the length of a dynamic array. Directly writing to .length is forbidden.

Converts a bytes to its Bytes64 string representation.

Converts a bytes to its Bytes64Url string representation. Output is not padded with = as specified in rfc4648.

Retrieves the block hash for any historical block within the supported range.

NOTE: The function gracefully handles future blocks and blocks beyond the history window by returning zero, consistent with the EVM's native BLOCKHASH behavior.

Forward search for s in buffer

• If s is present in the buffer, returns the index of the first instance
• If s is not present in the buffer, returns type(uint256).max

NOTE: replicates the behavior of Javascript's Array.indexOf

Forward search for s in buffer starting at position pos

• If s is present in the buffer (at or after pos), returns the index of the next instance
• If s is not present in the buffer (at or after pos), returns type(uint256).max

NOTE: replicates the behavior of Javascript's Array.indexOf

Backward search for s in buffer

• If s is present in the buffer, returns the index of the last instance
• If s is not present in the buffer, returns type(uint256).max

NOTE: replicates the behavior of Javascript's Array.lastIndexOf

Backward search for s in buffer starting at position pos

• If s is present in the buffer (at or before pos), returns the index of the previous instance
• If s is not present in the buffer (at or before pos), returns type(uint256).max

NOTE: replicates the behavior of Javascript's Array.lastIndexOf

Copies the content of buffer, from start (included) to the end of buffer into a new bytes object in memory.

NOTE: replicates the behavior of Javascript's Array.slice

Copies the content of buffer, from start (included) to end (excluded) into a new bytes object in memory. The end argument is truncated to the length of the buffer.

NOTE: replicates the behavior of Javascript's Array.slice

Moves the content of buffer, from start (included) to the end of buffer to the start of that buffer.

NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use Bytes.slice instead

Moves the content of buffer, from start (included) to end (excluded) to the start of that buffer. The end argument is truncated to the length of the buffer.

NOTE: This function modifies the provided buffer in place. If you need to preserve the original buffer, use Bytes.slice instead

Returns true if the two byte buffers are equal.

Reverses the byte order of a bytes32 value, converting between little-endian and big-endian. Inspired in Reverse Parallel

Same as Bytes.reverseBytes32 but optimized for 128-bit values.

Same as Bytes.reverseBytes32 but optimized for 64-bit values.

Same as Bytes.reverseBytes32 but optimized for 32-bit values.

Same as Bytes.reverseBytes32 but optimized for 16-bit values.

Counts the number of leading zero bits a bytes array. Returns 8 * buffer.length if the buffer is all zeros.

Return the CAIP-10 identifier for an account on the current (local) chain.

Return the CAIP-10 identifier for a given caip2 chain and account.

NOTE: This function does not verify that the inputs are properly formatted.

Parse a CAIP-10 identifier into its components.

NOTE: This function does not verify that the CAIP-10 input is properly formatted. The caip2 return can be parsed using the CAIP2 library.

Return the CAIP-2 identifier for the current (local) chain.

Return the CAIP-2 identifier for a given namespace and reference.

NOTE: This function does not verify that the inputs are properly formatted.

Parse a CAIP-2 identifier into its components.

NOTE: This function does not verify that the CAIP-2 input is properly formatted.

Deploys a contract using CREATE2. The address where the contract will be deployed can be known in advance via Create2.computeAddress.

The bytecode for a contract can be obtained from Solidity with type(contractName).creationCode.

Requirements:

• bytecode must not be empty.
• salt must have not been used for bytecode already.
• the factory must have a balance of at least amount.
• if amount is non-zero, bytecode must have a payable constructor.

Returns the address where a contract will be stored if deployed via Create2.deploy. Any change in the bytecodeHash or salt will result in a new destination address.

Returns the address where a contract will be stored if deployed via Create2.deploy from a contract located at deployer. If deployer is this contract's address, returns the same value as Create2.computeAddress.

There's no code to deploy.

The ETH balance of the account is not enough to perform the operation.

A call to an address target failed. The target may have reverted.

The deployment failed.

A necessary precompile is missing.

Returns a Pointer to the current free Pointer.

Sets the free Pointer to a specific value.

Pointer to bytes32. Expects a pointer to a properly ABI-encoded bytes object.

bytes32 to Pointer. Expects a pointer to a properly ABI-encoded bytes object.

Receives and executes a batch of function calls on this contract.

Returns the next unused nonce for an address.

Consumes a nonce.

Returns the current value and increments nonce.

Same as Nonces._useNonce but checking that nonce is the next valid for owner.

The nonce used for an account is not the expected current nonce.

Returns the next unused nonce for an address and key. Result contains the key prefix.

Consumes the next unused nonce for an address and key.

Returns the current value without the key prefix. Consumed nonce is increased, so calling this function twice with the same arguments will return different (sequential) results.

Same as Nonces._useNonce but checking that nonce is the next valid for owner.

This version takes the key and the nonce in a single uint256 parameter:

• use the first 24 bytes for the key
• use the last 8 bytes for the nonce

Same as Nonces._useNonce but checking that nonce is the next valid for owner.

This version takes the key and the nonce as two different parameters.

Reverts with a panic code. Recommended to use with the internal constants with predefined codes.

Modifier to make a function callable only when the contract is not paused.

Requirements:

• The contract must not be paused.

Modifier to make a function callable only when the contract is paused.

Requirements:

• The contract must be paused.

Returns true if the contract is paused, and false otherwise.

Throws if the contract is paused.

Throws if the contract is not paused.

Triggers stopped state.

Requirements:

• The contract must not be paused.

Returns to normal state.

Requirements:

• The contract must be paused.

Emitted when the pause is triggered by account.

Emitted when the pause is lifted by account.

The operation failed because the contract is paused.

The operation failed because the contract is not paused.

Prevents a contract from calling itself, directly or indirectly. Calling a nonReentrant function from another nonReentrant function is not supported. It is possible to prevent this from happening by making the nonReentrant function external, and making it call a private function that does the actual work.

Returns true if the reentrancy guard is currently set to "entered", which indicates there is a nonReentrant function in the call stack.

Unauthorized reentrant call.

Prevents a contract from calling itself, directly or indirectly. Calling a nonReentrant function from another nonReentrant function is not supported. It is possible to prevent this from happening by making the nonReentrant function external, and making it call a private function that does the actual work.

Returns true if the reentrancy guard is currently set to "entered", which indicates there is a nonReentrant function in the call stack.

Unauthorized reentrant call.

Encode a string of at most 31 chars into a ShortString.

This will trigger a StringTooLong error is the input string is too long.

Decode a ShortString back to a "normal" string.

Return the length of a ShortString.

Encode a string into a ShortString, or write it to storage if it is too long.

Decode a string that was encoded to ShortString or written to storage using ShortStrings.toShortStringWithFallback.

Return the length of a string that was encoded to ShortString or written to storage using ShortStrings.toShortStringWithFallback.

actual characters as the UTF-8 encoding of a single character can span over multiple bytes.

Derive an ERC-7201 slot from a string (namespace).

Add an offset to a slot to get the n-th element of a structure or an array.

Derive the location of the first element in an array from the slot where the length is stored.

Derive the location of a mapping element from the key.

Derive the location of a mapping element from the key.

Derive the location of a mapping element from the key.

Derive the location of a mapping element from the key.

Derive the location of a mapping element from the key.

Derive the location of a mapping element from the key.

Derive the location of a mapping element from the key.

Returns an AddressSlot with member value located at slot.

Returns a BooleanSlot with member value located at slot.

Returns a Bytes32Slot with member value located at slot.

Returns a Uint256Slot with member value located at slot.

Returns a Int256Slot with member value located at slot.

Returns a StringSlot with member value located at slot.

Returns an StringSlot representation of the string storage pointer store.

Returns a BytesSlot with member value located at slot.

Returns an BytesSlot representation of the bytes storage pointer store.

Converts a uint256 to its ASCII string decimal representation.

Converts a int256 to its ASCII string decimal representation.

Converts a uint256 to its ASCII string hexadecimal representation.

Converts a uint256 to its ASCII string hexadecimal representation with fixed length.

Converts an address with fixed length of 20 bytes to its not checksummed ASCII string hexadecimal representation.

Converts an address with fixed length of 20 bytes to its checksummed ASCII string hexadecimal representation, according to EIP-55.

Converts a bytes buffer to its ASCII string hexadecimal representation.

Returns true if the two strings are equal.

Parse a decimal string and returns the value as a uint256.

Requirements:

• The string must be formatted as [0-9]*
• The result must fit into an uint256 type

Variant of #Strings-parseUint-string- that parses a substring of input located between position begin (included) and end (excluded).

Requirements:

• The substring must be formatted as [0-9]*
• The result must fit into an uint256 type

Variant of #Strings-parseUint-string- that returns false if the parsing fails because of an invalid character.

NOTE: This function will revert if the result does not fit in a uint256.

Variant of #Strings-parseUint-string-uint256-uint256- that returns false if the parsing fails because of an invalid character.

NOTE: This function will revert if the result does not fit in a uint256.

Parse a decimal string and returns the value as a int256.

Requirements:

• The string must be formatted as [-+]?[0-9]*
• The result must fit in an int256 type.

Variant of #Strings-parseInt-string- that parses a substring of input located between position begin (included) and end (excluded).

Requirements:

• The substring must be formatted as [-+]?[0-9]*
• The result must fit in an int256 type.

Variant of #Strings-parseInt-string- that returns false if the parsing fails because of an invalid character or if the result does not fit in a int256.

NOTE: This function will revert if the absolute value of the result does not fit in a uint256.

Variant of #Strings-parseInt-string-uint256-uint256- that returns false if the parsing fails because of an invalid character or if the result does not fit in a int256.

NOTE: This function will revert if the absolute value of the result does not fit in a uint256.

Parse a hexadecimal string (with or without "0x" prefix), and returns the value as a uint256.

Requirements:

• The string must be formatted as (0x)?[0-9a-fA-F]*
• The result must fit in an uint256 type.

Variant of #Strings-parseHexUint-string- that parses a substring of input located between position begin (included) and end (excluded).

Requirements:

• The substring must be formatted as (0x)?[0-9a-fA-F]*
• The result must fit in an uint256 type.

Variant of #Strings-parseHexUint-string- that returns false if the parsing fails because of an invalid character.

NOTE: This function will revert if the result does not fit in a uint256.

Variant of #Strings-parseHexUint-string-uint256-uint256- that returns false if the parsing fails because of an invalid character.

NOTE: This function will revert if the result does not fit in a uint256.

Parse a hexadecimal string (with or without "0x" prefix), and returns the value as an address.

Requirements:

• The string must be formatted as (0x)?[0-9a-fA-F][SafeCast.toUint240](#SafeCast-toUint240-uint256-)

Variant of #Strings-parseAddress-string- that parses a substring of input located between position begin (included) and end (excluded).

Requirements:

• The substring must be formatted as (0x)?[0-9a-fA-F][SafeCast.toUint240](#SafeCast-toUint240-uint256-)

Variant of #Strings-parseAddress-string- that returns false if the parsing fails because the input is not a properly formatted address. See #Strings-parseAddress-string- requirements.

Variant of #Strings-parseAddress-string-uint256-uint256- that returns false if the parsing fails because input is not a properly formatted address. See #Strings-parseAddress-string-uint256-uint256- requirements.

Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata.

NOTE: This function escapes all unicode characters, and not just the ones in ranges defined in section 2.5 of RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). ECMAScript's JSON.parse does recover escaped unicode characters that are not in this range, but other tooling may provide different results.

The value string doesn't fit in the specified length.

The string being parsed contains characters that are not in scope of the given base.

The string being parsed is not a properly formatted address.

Cast an arbitrary slot to a AddressSlot.

Cast an arbitrary slot to a BooleanSlot.

Cast an arbitrary slot to a Bytes32Slot.

Cast an arbitrary slot to a Uint256Slot.

Cast an arbitrary slot to a Int256Slot.

Load the value held at location slot in transient storage.

Store value at location slot in transient storage.

Load the value held at location slot in transient storage.

Store value at location slot in transient storage.

Load the value held at location slot in transient storage.

Store value at location slot in transient storage.

Load the value held at location slot in transient storage.

Store value at location slot in transient storage.

Load the value held at location slot in transient storage.

Store value at location slot in transient storage.

Format an ERC-7930 interoperable address (version 1) from its components chainType, chainReference and addr. This is a generic function that supports any chain type, chain reference and address supported by ERC-7390, including interoperable addresses with empty chain reference or empty address.

Variant of #InteroperableAddress-formatV1-bytes2-bytes-bytes- specific to EVM chains. Returns the ERC-7930 interoperable address (version 1) for a given chainid and ethereum address.

Variant of #InteroperableAddress-formatV1-bytes2-bytes-bytes- that specifies an EVM chain without an address.

Variant of #InteroperableAddress-formatV1-bytes2-bytes-bytes- that specifies an EVM address without a chain reference.

Parse a ERC-7930 interoperable address (version 1) into its different components. Reverts if the input is not following a version 1 of ERC-7930

Variant of InteroperableAddress.parseV1 that handles calldata slices to reduce memory copy costs.

Variant of InteroperableAddress.parseV1 that does not revert on invalid input. Instead, it returns false as the first return value to indicate parsing failure when the input does not follow version 1 of ERC-7930.

Variant of InteroperableAddress.tryParseV1 that handles calldata slices to reduce memory copy costs.

Parse a ERC-7930 interoperable address (version 1) corresponding to an EIP-155 chain. The chainId and addr return values will be zero if the input doesn't include a chainReference or an address, respectively.

Requirements:

• The input must be a valid ERC-7930 interoperable address (version 1)
• The underlying chainType must be "eip-155"

Variant of InteroperableAddress.parseEvmV1 that handles calldata slices to reduce memory copy costs.

Variant of InteroperableAddress.parseEvmV1 that does not revert on invalid input. Instead, it returns false as the first return value to indicate parsing failure when the input does not follow version 1 of ERC-7930.

Variant of InteroperableAddress.tryParseEvmV1 that handles calldata slices to reduce memory copy costs.

Returns true if this contract implements the interface defined by interfaceId. See the corresponding ERC section to learn more about how these ids are created.

This function call must use less than 30 000 gas.

Returns true if account supports the IERC165 interface.

Returns true if account supports the interface defined by interfaceId. Support for IERC165 itself is queried automatically.

See IERC165.supportsInterface.

Returns a boolean array where each value corresponds to the interfaces passed in and whether they're supported or not. This allows you to batch check interfaces for a contract where your expectation is that some interfaces may not be supported.

See IERC165.supportsInterface.

Returns true if account supports all the interfaces defined in interfaceIds. Support for IERC165 itself is queried automatically.

Batch-querying can lead to gas savings by skipping repeated checks for IERC165 support.

See IERC165.supportsInterface.

Assumes that account contains a contract that supports ERC-165, otherwise the behavior of this method is undefined. This precondition can be checked with ERC165Checker.supportsERC165.

Some precompiled contracts will falsely indicate support for a given interface, so caution should be exercised when using this function.

Interface identification is specified in ERC-165.

Returns true if this contract implements the interface defined by interfaceId. See the corresponding ERC section to learn more about how these ids are created.

This function call must use less than 30 000 gas.

Return the 512-bit addition of two uint256.

The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.

Return the 512-bit multiplication of two uint256.

The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.

Returns the addition of two unsigned integers, with a success flag (no overflow).

Returns the subtraction of two unsigned integers, with a success flag (no overflow).

Returns the multiplication of two unsigned integers, with a success flag (no overflow).

Returns the division of two unsigned integers, with a success flag (no division by zero).

Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).

Unsigned saturating addition, bounds to 2²⁵⁶ - 1 instead of overflowing.

Unsigned saturating subtraction, bounds to zero instead of overflowing.

Unsigned saturating multiplication, bounds to 2²⁵⁶ - 1 instead of overflowing.

Branchless ternary evaluation for a ? b : c. Gas costs are constant.

However, the compiler may optimize Solidity ternary operations (i.e. a ? b : c) to only compute one branch when needed, making this function more expensive.

Returns the largest of two numbers.

Returns the smallest of two numbers.

Returns the average of two numbers. The result is rounded towards zero.

Returns the ceiling of the division of two numbers.

This differs from standard division with / in that it rounds towards infinity instead of rounding towards zero.

Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0.

Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by Uniswap Labs also under MIT license.

Calculates x * y / denominator with full precision, following the selected rounding direction.

Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.

Calculates x * y >> n with full precision, following the selected rounding direction.

Calculate the modular multiplicative inverse of a number in Z/nZ.

If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0. If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.

If the input value is not inversible, 0 is returned.

NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the inverse using Math.modExp(a, n - 2, n). See Math.invModPrime.

Variant of Math.invMod. More efficient, but only works if p is known to be a prime greater than 2.

From Fermat's little theorem, we know that if p is prime, then a**(p-1) ≡ 1 mod p. As a consequence, we have a * a**(p-2) ≡ 1 mod p, which means that a**(p-2) is the modular multiplicative inverse of a in Fp.

NOTE: this function does NOT check that p is a prime greater than 2.

Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)

Requirements:

• modulus can't be zero
• underlying staticcall to precompile must succeed

sure the chain you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in EIP-198. Otherwise, the underlying function will succeed given the lack of a revert, but the result may be incorrectly interpreted as 0.

Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m). It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying to operate modulo 0 or if the underlying precompile reverted.

you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in EIP-198. Otherwise, the underlying function will succeed given the lack of a revert, but the result may be incorrectly interpreted as 0.

Variant of Math.modExp that supports inputs of arbitrary length.

Variant of Math.tryModExp that supports inputs of arbitrary length.

Returns the square root of a number. If the number is not a perfect square, the value is rounded towards zero.

This method is based on Newton's method for computing square roots; the algorithm is restricted to only using integer operations.

Calculates sqrt(a), following the selected rounding direction.

Return the log in base 2 of a positive value rounded towards zero. Returns 0 if given 0.

Return the log in base 2, following the selected rounding direction, of a positive value. Returns 0 if given 0.

Return the log in base 10 of a positive value rounded towards zero. Returns 0 if given 0.

Return the log in base 10, following the selected rounding direction, of a positive value. Returns 0 if given 0.

Return the log in base 256 of a positive value rounded towards zero. Returns 0 if given 0.

Adding one to the result gives the number of pairs of hex symbols needed to represent value as a hex string.

Return the log in base 256, following the selected rounding direction, of a positive value. Returns 0 if given 0.

Returns whether a provided rounding mode is considered rounding up for unsigned integers.

Counts the number of leading zero bits in a uint256.

Returns the downcasted uint248 from uint256, reverting on overflow (when the input is greater than largest uint248).

Counterpart to Solidity's uint248 operator.

Requirements:

• input must fit into 248 bits

Returns the downcasted uint240 from uint256, reverting on overflow (when the input is greater than largest uint240).

Counterpart to Solidity's uint240 operator.

Requirements:

• input must fit into 240 bits

Returns the downcasted uint232 from uint256, reverting on overflow (when the input is greater than largest uint232).

Counterpart to Solidity's uint232 operator.

Requirements:

• input must fit into 232 bits

Returns the downcasted uint224 from uint256, reverting on overflow (when the input is greater than largest uint224).

Counterpart to Solidity's uint224 operator.

Requirements:

• input must fit into 224 bits

Returns the downcasted uint216 from uint256, reverting on overflow (when the input is greater than largest uint216).

Counterpart to Solidity's uint216 operator.

Requirements:

• input must fit into 216 bits

Returns the downcasted uint208 from uint256, reverting on overflow (when the input is greater than largest uint208).

Counterpart to Solidity's uint208 operator.

Requirements:

• input must fit into 208 bits

Returns the downcasted uint200 from uint256, reverting on overflow (when the input is greater than largest uint200).

Counterpart to Solidity's uint200 operator.

Requirements:

• input must fit into 200 bits

Returns the downcasted uint192 from uint256, reverting on overflow (when the input is greater than largest uint192).

Counterpart to Solidity's uint192 operator.

Requirements:

• input must fit into 192 bits

Returns the downcasted uint184 from uint256, reverting on overflow (when the input is greater than largest uint184).

Counterpart to Solidity's uint184 operator.

Requirements:

• input must fit into 184 bits

Returns the downcasted uint176 from uint256, reverting on overflow (when the input is greater than largest uint176).

Counterpart to Solidity's uint176 operator.

Requirements:

• input must fit into 176 bits

Returns the downcasted uint168 from uint256, reverting on overflow (when the input is greater than largest uint168).

Counterpart to Solidity's uint168 operator.

Requirements:

• input must fit into 168 bits

Returns the downcasted uint160 from uint256, reverting on overflow (when the input is greater than largest uint160).

Counterpart to Solidity's uint160 operator.

Requirements:

• input must fit into 160 bits

Returns the downcasted uint152 from uint256, reverting on overflow (when the input is greater than largest uint152).

Counterpart to Solidity's uint152 operator.

Requirements:

• input must fit into 152 bits

Returns the downcasted uint144 from uint256, reverting on overflow (when the input is greater than largest uint144).

Counterpart to Solidity's uint144 operator.

Requirements:

• input must fit into 144 bits

Returns the downcasted uint136 from uint256, reverting on overflow (when the input is greater than largest uint136).

Counterpart to Solidity's uint136 operator.

Requirements:

• input must fit into 136 bits

Returns the downcasted uint128 from uint256, reverting on overflow (when the input is greater than largest uint128).

Counterpart to Solidity's uint128 operator.

Requirements:

• input must fit into 128 bits

Returns the downcasted uint120 from uint256, reverting on overflow (when the input is greater than largest uint120).

Counterpart to Solidity's uint120 operator.

Requirements:

• input must fit into 120 bits

Returns the downcasted uint112 from uint256, reverting on overflow (when the input is greater than largest uint112).

Counterpart to Solidity's uint112 operator.

Requirements:

• input must fit into 112 bits

Returns the downcasted uint104 from uint256, reverting on overflow (when the input is greater than largest uint104).

Counterpart to Solidity's uint104 operator.

Requirements:

• input must fit into 104 bits

Returns the downcasted uint96 from uint256, reverting on overflow (when the input is greater than largest uint96).

Counterpart to Solidity's uint96 operator.

Requirements:

• input must fit into 96 bits