polkamarkets-js 3.1.10 → 3.2.0

package/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
+// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
 // This file was procedurally generated from scripts/generate/templates/SafeCast.js.
 
-pragma solidity ^0.8.0;
+pragma solidity ^0.8.20;
 
 /**
- * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
+ * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
  * checks.
  *
  * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
@@ -15,11 +15,28 @@ pragma solidity ^0.8.0;
  *
  * Using this library instead of the unchecked operations eliminates an entire
  * class of bugs, so it's recommended to use it always.
- *
- * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
- * all math on `uint256` and `int256` and then downcasting.
  */
 library SafeCast {
+    /**
+     * @dev Value doesn't fit in an uint of `bits` size.
+     */
+    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
+
+    /**
+     * @dev An int value doesn't fit in an uint of `bits` size.
+     */
+    error SafeCastOverflowedIntToUint(int256 value);
+
+    /**
+     * @dev Value doesn't fit in an int of `bits` size.
+     */
+    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
+
+    /**
+     * @dev An uint value doesn't fit in an int of `bits` size.
+     */
+    error SafeCastOverflowedUintToInt(uint256 value);
+
     /**
      * @dev Returns the downcasted uint248 from uint256, reverting on
      * overflow (when the input is greater than largest uint248).
@@ -29,11 +46,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 248 bits
-     *
-     * _Available since v4.7._
      */
     function toUint248(uint256 value) internal pure returns (uint248) {
-        require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
+        if (value > type(uint248).max) {
+            revert SafeCastOverflowedUintDowncast(248, value);
+        }
         return uint248(value);
     }
 
@@ -46,11 +63,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 240 bits
-     *
-     * _Available since v4.7._
      */
     function toUint240(uint256 value) internal pure returns (uint240) {
-        require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
+        if (value > type(uint240).max) {
+            revert SafeCastOverflowedUintDowncast(240, value);
+        }
         return uint240(value);
     }
 
@@ -63,11 +80,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 232 bits
-     *
-     * _Available since v4.7._
      */
     function toUint232(uint256 value) internal pure returns (uint232) {
-        require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
+        if (value > type(uint232).max) {
+            revert SafeCastOverflowedUintDowncast(232, value);
+        }
         return uint232(value);
     }
 
@@ -80,11 +97,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 224 bits
-     *
-     * _Available since v4.2._
      */
     function toUint224(uint256 value) internal pure returns (uint224) {
-        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
+        if (value > type(uint224).max) {
+            revert SafeCastOverflowedUintDowncast(224, value);
+        }
         return uint224(value);
     }
 
@@ -97,11 +114,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 216 bits
-     *
-     * _Available since v4.7._
      */
     function toUint216(uint256 value) internal pure returns (uint216) {
-        require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
+        if (value > type(uint216).max) {
+            revert SafeCastOverflowedUintDowncast(216, value);
+        }
         return uint216(value);
     }
 
@@ -114,11 +131,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 208 bits
-     *
-     * _Available since v4.7._
      */
     function toUint208(uint256 value) internal pure returns (uint208) {
-        require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
+        if (value > type(uint208).max) {
+            revert SafeCastOverflowedUintDowncast(208, value);
+        }
         return uint208(value);
     }
 
@@ -131,11 +148,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 200 bits
-     *
-     * _Available since v4.7._
      */
     function toUint200(uint256 value) internal pure returns (uint200) {
-        require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
+        if (value > type(uint200).max) {
+            revert SafeCastOverflowedUintDowncast(200, value);
+        }
         return uint200(value);
     }
 
@@ -148,11 +165,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 192 bits
-     *
-     * _Available since v4.7._
      */
     function toUint192(uint256 value) internal pure returns (uint192) {
-        require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
+        if (value > type(uint192).max) {
+            revert SafeCastOverflowedUintDowncast(192, value);
+        }
         return uint192(value);
     }
 
@@ -165,11 +182,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 184 bits
-     *
-     * _Available since v4.7._
      */
     function toUint184(uint256 value) internal pure returns (uint184) {
-        require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
+        if (value > type(uint184).max) {
+            revert SafeCastOverflowedUintDowncast(184, value);
+        }
         return uint184(value);
     }
 
@@ -182,11 +199,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 176 bits
-     *
-     * _Available since v4.7._
      */
     function toUint176(uint256 value) internal pure returns (uint176) {
-        require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
+        if (value > type(uint176).max) {
+            revert SafeCastOverflowedUintDowncast(176, value);
+        }
         return uint176(value);
     }
 
@@ -199,11 +216,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 168 bits
-     *
-     * _Available since v4.7._
      */
     function toUint168(uint256 value) internal pure returns (uint168) {
-        require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
+        if (value > type(uint168).max) {
+            revert SafeCastOverflowedUintDowncast(168, value);
+        }
         return uint168(value);
     }
 
@@ -216,11 +233,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 160 bits
-     *
-     * _Available since v4.7._
      */
     function toUint160(uint256 value) internal pure returns (uint160) {
-        require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
+        if (value > type(uint160).max) {
+            revert SafeCastOverflowedUintDowncast(160, value);
+        }
         return uint160(value);
     }
 
@@ -233,11 +250,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 152 bits
-     *
-     * _Available since v4.7._
      */
     function toUint152(uint256 value) internal pure returns (uint152) {
-        require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
+        if (value > type(uint152).max) {
+            revert SafeCastOverflowedUintDowncast(152, value);
+        }
         return uint152(value);
     }
 
@@ -250,11 +267,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 144 bits
-     *
-     * _Available since v4.7._
      */
     function toUint144(uint256 value) internal pure returns (uint144) {
-        require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
+        if (value > type(uint144).max) {
+            revert SafeCastOverflowedUintDowncast(144, value);
+        }
         return uint144(value);
     }
 
@@ -267,11 +284,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 136 bits
-     *
-     * _Available since v4.7._
      */
     function toUint136(uint256 value) internal pure returns (uint136) {
-        require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
+        if (value > type(uint136).max) {
+            revert SafeCastOverflowedUintDowncast(136, value);
+        }
         return uint136(value);
     }
 
@@ -284,11 +301,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 128 bits
-     *
-     * _Available since v2.5._
      */
     function toUint128(uint256 value) internal pure returns (uint128) {
-        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
+        if (value > type(uint128).max) {
+            revert SafeCastOverflowedUintDowncast(128, value);
+        }
         return uint128(value);
     }
 
@@ -301,11 +318,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 120 bits
-     *
-     * _Available since v4.7._
      */
     function toUint120(uint256 value) internal pure returns (uint120) {
-        require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
+        if (value > type(uint120).max) {
+            revert SafeCastOverflowedUintDowncast(120, value);
+        }
         return uint120(value);
     }
 
@@ -318,11 +335,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 112 bits
-     *
-     * _Available since v4.7._
      */
     function toUint112(uint256 value) internal pure returns (uint112) {
-        require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
+        if (value > type(uint112).max) {
+            revert SafeCastOverflowedUintDowncast(112, value);
+        }
         return uint112(value);
     }
 
@@ -335,11 +352,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 104 bits
-     *
-     * _Available since v4.7._
      */
     function toUint104(uint256 value) internal pure returns (uint104) {
-        require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
+        if (value > type(uint104).max) {
+            revert SafeCastOverflowedUintDowncast(104, value);
+        }
         return uint104(value);
     }
 
@@ -352,11 +369,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 96 bits
-     *
-     * _Available since v4.2._
      */
     function toUint96(uint256 value) internal pure returns (uint96) {
-        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
+        if (value > type(uint96).max) {
+            revert SafeCastOverflowedUintDowncast(96, value);
+        }
         return uint96(value);
     }
 
@@ -369,11 +386,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 88 bits
-     *
-     * _Available since v4.7._
      */
     function toUint88(uint256 value) internal pure returns (uint88) {
-        require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
+        if (value > type(uint88).max) {
+            revert SafeCastOverflowedUintDowncast(88, value);
+        }
         return uint88(value);
     }
 
@@ -386,11 +403,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 80 bits
-     *
-     * _Available since v4.7._
      */
     function toUint80(uint256 value) internal pure returns (uint80) {
-        require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
+        if (value > type(uint80).max) {
+            revert SafeCastOverflowedUintDowncast(80, value);
+        }
         return uint80(value);
     }
 
@@ -403,11 +420,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 72 bits
-     *
-     * _Available since v4.7._
      */
     function toUint72(uint256 value) internal pure returns (uint72) {
-        require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
+        if (value > type(uint72).max) {
+            revert SafeCastOverflowedUintDowncast(72, value);
+        }
         return uint72(value);
     }
 
@@ -420,11 +437,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 64 bits
-     *
-     * _Available since v2.5._
      */
     function toUint64(uint256 value) internal pure returns (uint64) {
-        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
+        if (value > type(uint64).max) {
+            revert SafeCastOverflowedUintDowncast(64, value);
+        }
         return uint64(value);
     }
 
@@ -437,11 +454,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 56 bits
-     *
-     * _Available since v4.7._
      */
     function toUint56(uint256 value) internal pure returns (uint56) {
-        require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
+        if (value > type(uint56).max) {
+            revert SafeCastOverflowedUintDowncast(56, value);
+        }
         return uint56(value);
     }
 
@@ -454,11 +471,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 48 bits
-     *
-     * _Available since v4.7._
      */
     function toUint48(uint256 value) internal pure returns (uint48) {
-        require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
+        if (value > type(uint48).max) {
+            revert SafeCastOverflowedUintDowncast(48, value);
+        }
         return uint48(value);
     }
 
@@ -471,11 +488,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 40 bits
-     *
-     * _Available since v4.7._
      */
     function toUint40(uint256 value) internal pure returns (uint40) {
-        require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
+        if (value > type(uint40).max) {
+            revert SafeCastOverflowedUintDowncast(40, value);
+        }
         return uint40(value);
     }
 
@@ -488,11 +505,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 32 bits
-     *
-     * _Available since v2.5._
      */
     function toUint32(uint256 value) internal pure returns (uint32) {
-        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
+        if (value > type(uint32).max) {
+            revert SafeCastOverflowedUintDowncast(32, value);
+        }
         return uint32(value);
     }
 
@@ -505,11 +522,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 24 bits
-     *
-     * _Available since v4.7._
      */
     function toUint24(uint256 value) internal pure returns (uint24) {
-        require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
+        if (value > type(uint24).max) {
+            revert SafeCastOverflowedUintDowncast(24, value);
+        }
         return uint24(value);
     }
 
@@ -522,11 +539,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 16 bits
-     *
-     * _Available since v2.5._
      */
     function toUint16(uint256 value) internal pure returns (uint16) {
-        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
+        if (value > type(uint16).max) {
+            revert SafeCastOverflowedUintDowncast(16, value);
+        }
         return uint16(value);
     }
 
@@ -539,11 +556,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 8 bits
-     *
-     * _Available since v2.5._
      */
     function toUint8(uint256 value) internal pure returns (uint8) {
-        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
+        if (value > type(uint8).max) {
+            revert SafeCastOverflowedUintDowncast(8, value);
+        }
         return uint8(value);
     }
 
@@ -553,11 +570,11 @@ library SafeCast {
      * Requirements:
      *
      * - input must be greater than or equal to 0.
-     *
-     * _Available since v3.0._
      */
     function toUint256(int256 value) internal pure returns (uint256) {
-        require(value >= 0, "SafeCast: value must be positive");
+        if (value < 0) {
+            revert SafeCastOverflowedIntToUint(value);
+        }
         return uint256(value);
     }
 
@@ -571,12 +588,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 248 bits
-     *
-     * _Available since v4.7._
      */
     function toInt248(int256 value) internal pure returns (int248 downcasted) {
         downcasted = int248(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(248, value);
+        }
     }
 
     /**
@@ -589,12 +606,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 240 bits
-     *
-     * _Available since v4.7._
      */
     function toInt240(int256 value) internal pure returns (int240 downcasted) {
         downcasted = int240(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(240, value);
+        }
     }
 
     /**
@@ -607,12 +624,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 232 bits
-     *
-     * _Available since v4.7._
      */
     function toInt232(int256 value) internal pure returns (int232 downcasted) {
         downcasted = int232(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(232, value);
+        }
     }
 
     /**
@@ -625,12 +642,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 224 bits
-     *
-     * _Available since v4.7._
      */
     function toInt224(int256 value) internal pure returns (int224 downcasted) {
         downcasted = int224(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(224, value);
+        }
     }
 
     /**
@@ -643,12 +660,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 216 bits
-     *
-     * _Available since v4.7._
      */
     function toInt216(int256 value) internal pure returns (int216 downcasted) {
         downcasted = int216(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(216, value);
+        }
     }
 
     /**
@@ -661,12 +678,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 208 bits
-     *
-     * _Available since v4.7._
      */
     function toInt208(int256 value) internal pure returns (int208 downcasted) {
         downcasted = int208(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(208, value);
+        }
     }
 
     /**
@@ -679,12 +696,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 200 bits
-     *
-     * _Available since v4.7._
      */
     function toInt200(int256 value) internal pure returns (int200 downcasted) {
         downcasted = int200(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(200, value);
+        }
     }
 
     /**
@@ -697,12 +714,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 192 bits
-     *
-     * _Available since v4.7._
      */
     function toInt192(int256 value) internal pure returns (int192 downcasted) {
         downcasted = int192(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(192, value);
+        }
     }
 
     /**
@@ -715,12 +732,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 184 bits
-     *
-     * _Available since v4.7._
      */
     function toInt184(int256 value) internal pure returns (int184 downcasted) {
         downcasted = int184(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(184, value);
+        }
     }
 
     /**
@@ -733,12 +750,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 176 bits
-     *
-     * _Available since v4.7._
      */
     function toInt176(int256 value) internal pure returns (int176 downcasted) {
         downcasted = int176(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(176, value);
+        }
     }
 
     /**
@@ -751,12 +768,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 168 bits
-     *
-     * _Available since v4.7._
      */
     function toInt168(int256 value) internal pure returns (int168 downcasted) {
         downcasted = int168(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(168, value);
+        }
     }
 
     /**
@@ -769,12 +786,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 160 bits
-     *
-     * _Available since v4.7._
      */
     function toInt160(int256 value) internal pure returns (int160 downcasted) {
         downcasted = int160(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(160, value);
+        }
     }
 
     /**
@@ -787,12 +804,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 152 bits
-     *
-     * _Available since v4.7._
      */
     function toInt152(int256 value) internal pure returns (int152 downcasted) {
         downcasted = int152(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(152, value);
+        }
     }
 
     /**
@@ -805,12 +822,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 144 bits
-     *
-     * _Available since v4.7._
      */
     function toInt144(int256 value) internal pure returns (int144 downcasted) {
         downcasted = int144(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(144, value);
+        }
     }
 
     /**
@@ -823,12 +840,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 136 bits
-     *
-     * _Available since v4.7._
      */
     function toInt136(int256 value) internal pure returns (int136 downcasted) {
         downcasted = int136(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(136, value);
+        }
     }
 
     /**
@@ -841,12 +858,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 128 bits
-     *
-     * _Available since v3.1._
      */
     function toInt128(int256 value) internal pure returns (int128 downcasted) {
         downcasted = int128(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(128, value);
+        }
     }
 
     /**
@@ -859,12 +876,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 120 bits
-     *
-     * _Available since v4.7._
      */
     function toInt120(int256 value) internal pure returns (int120 downcasted) {
         downcasted = int120(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(120, value);
+        }
     }
 
     /**
@@ -877,12 +894,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 112 bits
-     *
-     * _Available since v4.7._
      */
     function toInt112(int256 value) internal pure returns (int112 downcasted) {
         downcasted = int112(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(112, value);
+        }
     }
 
     /**
@@ -895,12 +912,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 104 bits
-     *
-     * _Available since v4.7._
      */
     function toInt104(int256 value) internal pure returns (int104 downcasted) {
         downcasted = int104(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(104, value);
+        }
     }
 
     /**
@@ -913,12 +930,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 96 bits
-     *
-     * _Available since v4.7._
      */
     function toInt96(int256 value) internal pure returns (int96 downcasted) {
         downcasted = int96(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(96, value);
+        }
     }
 
     /**
@@ -931,12 +948,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 88 bits
-     *
-     * _Available since v4.7._
      */
     function toInt88(int256 value) internal pure returns (int88 downcasted) {
         downcasted = int88(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(88, value);
+        }
     }
 
     /**
@@ -949,12 +966,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 80 bits
-     *
-     * _Available since v4.7._
      */
     function toInt80(int256 value) internal pure returns (int80 downcasted) {
         downcasted = int80(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(80, value);
+        }
     }
 
     /**
@@ -967,12 +984,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 72 bits
-     *
-     * _Available since v4.7._
      */
     function toInt72(int256 value) internal pure returns (int72 downcasted) {
         downcasted = int72(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(72, value);
+        }
     }
 
     /**
@@ -985,12 +1002,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 64 bits
-     *
-     * _Available since v3.1._
      */
     function toInt64(int256 value) internal pure returns (int64 downcasted) {
         downcasted = int64(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(64, value);
+        }
     }
 
     /**
@@ -1003,12 +1020,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 56 bits
-     *
-     * _Available since v4.7._
      */
     function toInt56(int256 value) internal pure returns (int56 downcasted) {
         downcasted = int56(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(56, value);
+        }
     }
 
     /**
@@ -1021,12 +1038,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 48 bits
-     *
-     * _Available since v4.7._
      */
     function toInt48(int256 value) internal pure returns (int48 downcasted) {
         downcasted = int48(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(48, value);
+        }
     }
 
     /**
@@ -1039,12 +1056,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 40 bits
-     *
-     * _Available since v4.7._
      */
     function toInt40(int256 value) internal pure returns (int40 downcasted) {
         downcasted = int40(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(40, value);
+        }
     }
 
     /**
@@ -1057,12 +1074,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 32 bits
-     *
-     * _Available since v3.1._
      */
     function toInt32(int256 value) internal pure returns (int32 downcasted) {
         downcasted = int32(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(32, value);
+        }
     }
 
     /**
@@ -1075,12 +1092,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 24 bits
-     *
-     * _Available since v4.7._
      */
     function toInt24(int256 value) internal pure returns (int24 downcasted) {
         downcasted = int24(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(24, value);
+        }
     }
 
     /**
@@ -1093,12 +1110,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 16 bits
-     *
-     * _Available since v3.1._
      */
     function toInt16(int256 value) internal pure returns (int16 downcasted) {
         downcasted = int16(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(16, value);
+        }
     }
 
     /**
@@ -1111,12 +1128,12 @@ library SafeCast {
      * Requirements:
      *
      * - input must fit into 8 bits
-     *
-     * _Available since v3.1._
      */
     function toInt8(int256 value) internal pure returns (int8 downcasted) {
         downcasted = int8(value);
-        require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
+        if (downcasted != value) {
+            revert SafeCastOverflowedIntDowncast(8, value);
+        }
     }
 
     /**
@@ -1125,12 +1142,21 @@ library SafeCast {
      * Requirements:
      *
      * - input must be less than or equal to maxInt256.
-     *
-     * _Available since v3.0._
      */
     function toInt256(uint256 value) internal pure returns (int256) {
         // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
-        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
+        if (value > uint256(type(int256).max)) {
+            revert SafeCastOverflowedUintToInt(value);
+        }
         return int256(value);
     }
+
+    /**
+     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
+     */
+    function toUint(bool b) internal pure returns (uint256 u) {
+        assembly ("memory-safe") {
+            u := iszero(iszero(b))
+        }
+    }
 }