From 02aa1aa8780bf8a46d1d01762336d7e5513754dd Mon Sep 17 00:00:00 2001 From: tommyrharper Date: Mon, 26 Feb 2024 19:27:32 +0000 Subject: [PATCH] =?UTF-8?q?=F0=9F=97=91=EF=B8=8F=20=F0=9F=91=B7?= =?UTF-8?q?=F0=9F=8F=BB=20Remove=20all=20.toUint()=20functionality?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Int128/BaseInt128/Casting.sol | 9 -------- src/Int128/BaseInt128/ValueType.sol | 2 +- src/Int128/BaseQuantoPerUSDInt128/Casting.sol | 13 ----------- .../BaseQuantoPerUSDInt128/ValueType.sol | 2 +- src/Int128/QuantoInt128/Casting.sol | 9 -------- src/Int128/QuantoInt128/ValueType.sol | 2 +- src/Int128/USDInt128/Casting.sol | 9 -------- src/Int128/USDInt128/ValueType.sol | 2 +- src/Int128/USDPerBaseInt128/Casting.sol | 9 -------- src/Int128/USDPerBaseInt128/ValueType.sol | 2 +- src/Int128/USDPerQuantoInt128/Casting.sol | 13 ----------- src/Int128/USDPerQuantoInt128/ValueType.sol | 2 +- src/Int256/BaseInt256/Casting.sol | 6 ----- src/Int256/BaseInt256/ValueType.sol | 2 +- src/Int256/BaseQuantoPerUSDInt256/Casting.sol | 11 +--------- .../BaseQuantoPerUSDInt256/ValueType.sol | 3 +-- src/Int256/QuantoInt256/Casting.sol | 6 ----- src/Int256/QuantoInt256/ValueType.sol | 2 +- src/Int256/USDInt256/Casting.sol | 6 ----- src/Int256/USDInt256/ValueType.sol | 2 +- src/Int256/USDPerBaseInt256/Casting.sol | 6 ----- src/Int256/USDPerBaseInt256/ValueType.sol | 3 +-- src/Int256/USDPerQuantoInt256/Casting.sol | 10 --------- src/Int256/USDPerQuantoInt256/ValueType.sol | 3 +-- test/Int128/BaseInt128.t.sol | 20 ----------------- test/Int128/BaseQuantoPerUSDInt128.t.sol | 21 ------------------ test/Int128/QuantoInt128.t.sol | 20 ----------------- test/Int128/USDInt128.t.sol | 21 +----------------- test/Int128/USDPerBaseInt128.t.sol | 20 ----------------- test/Int128/USDPerQuantoInt128.t.sol | 20 ----------------- test/Int256/BaseInt256.t.sol | 20 ----------------- test/Int256/BaseQuantoPerUSDInt256.t.sol | 21 ------------------ test/Int256/QuantoInt256.t.sol | 20 ----------------- test/Int256/USDInt256.t.sol | 22 +------------------ test/Int256/USDPerBaseInt256.t.sol | 20 ----------------- test/Int256/USDPerQuantoInt256.t.sol | 20 ----------------- 36 files changed, 15 insertions(+), 364 deletions(-) diff --git a/src/Int128/BaseInt128/Casting.sol b/src/Int128/BaseInt128/Casting.sol index 5f4df0b..764efac 100644 --- a/src/Int128/BaseInt128/Casting.sol +++ b/src/Int128/BaseInt128/Casting.sol @@ -2,10 +2,6 @@ pragma solidity >=0.8.19; import {BaseInt128} from "./ValueType.sol"; -import {BaseUint128} from "../../Uint128/BaseUint128/ValueType.sol"; -import {SafeCastI128} from "../../utils/SafeCast.sol"; - -using SafeCastI128 for int128; /// @notice Wraps a int128 number into the BaseInt128 value type. function wrap(int128 x) pure returns (BaseInt128 result) { @@ -16,8 +12,3 @@ function wrap(int128 x) pure returns (BaseInt128 result) { function unwrap(BaseInt128 x) pure returns (int128 result) { result = BaseInt128.unwrap(x); } - -/// @notice Converts a BaseInt128 number into BaseUint128. -function toUint(BaseInt128 x) pure returns (BaseUint128 result) { - result = BaseUint128.wrap(unwrap(x).toUint()); -} diff --git a/src/Int128/BaseInt128/ValueType.sol b/src/Int128/BaseInt128/ValueType.sol index dda3953..2ca5e3a 100644 --- a/src/Int128/BaseInt128/ValueType.sol +++ b/src/Int128/BaseInt128/ValueType.sol @@ -10,7 +10,7 @@ type BaseInt128 is int128; CASTING //////////////////////////////////////////////////////////////*/ -using {Casting.unwrap, Casting.toUint} for BaseInt128 global; +using {Casting.unwrap} for BaseInt128 global; /*////////////////////////////////////////////////////////////// HELPERS diff --git a/src/Int128/BaseQuantoPerUSDInt128/Casting.sol b/src/Int128/BaseQuantoPerUSDInt128/Casting.sol index 59309fc..5748d7c 100644 --- a/src/Int128/BaseQuantoPerUSDInt128/Casting.sol +++ b/src/Int128/BaseQuantoPerUSDInt128/Casting.sol @@ -2,11 +2,6 @@ pragma solidity >=0.8.19; import {BaseQuantoPerUSDInt128} from "./ValueType.sol"; -import {BaseQuantoPerUSDUint128} from - "../../Uint128/BaseQuantoPerUSDUint128/ValueType.sol"; -import {SafeCastI128} from "../../utils/SafeCast.sol"; - -using SafeCastI128 for int128; /// @notice Wraps a int128 number into the BaseQuantoPerUSDInt128 value type. function wrap(int128 x) pure returns (BaseQuantoPerUSDInt128 result) { @@ -17,11 +12,3 @@ function wrap(int128 x) pure returns (BaseQuantoPerUSDInt128 result) { function unwrap(BaseQuantoPerUSDInt128 x) pure returns (int128 result) { result = BaseQuantoPerUSDInt128.unwrap(x); } - -/// @notice Converts a BaseQuantoPerUSDInt128 number into BaseQuantoPerUSDUint128. -function toUint(BaseQuantoPerUSDInt128 x) - pure - returns (BaseQuantoPerUSDUint128 result) -{ - result = BaseQuantoPerUSDUint128.wrap(unwrap(x).toUint()); -} diff --git a/src/Int128/BaseQuantoPerUSDInt128/ValueType.sol b/src/Int128/BaseQuantoPerUSDInt128/ValueType.sol index ff623a3..a163e30 100644 --- a/src/Int128/BaseQuantoPerUSDInt128/ValueType.sol +++ b/src/Int128/BaseQuantoPerUSDInt128/ValueType.sol @@ -10,7 +10,7 @@ type BaseQuantoPerUSDInt128 is int128; CASTING //////////////////////////////////////////////////////////////*/ -using {Casting.unwrap, Casting.toUint} for BaseQuantoPerUSDInt128 global; +using {Casting.unwrap} for BaseQuantoPerUSDInt128 global; /*////////////////////////////////////////////////////////////// HELPERS diff --git a/src/Int128/QuantoInt128/Casting.sol b/src/Int128/QuantoInt128/Casting.sol index fb9a6e2..4e406b3 100644 --- a/src/Int128/QuantoInt128/Casting.sol +++ b/src/Int128/QuantoInt128/Casting.sol @@ -2,10 +2,6 @@ pragma solidity >=0.8.19; import {QuantoInt128} from "./ValueType.sol"; -import {QuantoUint128} from "../../Uint128/QuantoUint128/ValueType.sol"; -import {SafeCastI128} from "../../utils/SafeCast.sol"; - -using SafeCastI128 for int128; /// @notice Wraps a int128 number into the QuantoInt128 value type. function wrap(int128 x) pure returns (QuantoInt128 result) { @@ -16,8 +12,3 @@ function wrap(int128 x) pure returns (QuantoInt128 result) { function unwrap(QuantoInt128 x) pure returns (int128 result) { result = QuantoInt128.unwrap(x); } - -/// @notice Converts a QuantoInt128 number into QuantoUint128. -function toUint(QuantoInt128 x) pure returns (QuantoUint128 result) { - result = QuantoUint128.wrap(unwrap(x).toUint()); -} diff --git a/src/Int128/QuantoInt128/ValueType.sol b/src/Int128/QuantoInt128/ValueType.sol index 4c2f2c6..d3552b7 100644 --- a/src/Int128/QuantoInt128/ValueType.sol +++ b/src/Int128/QuantoInt128/ValueType.sol @@ -10,7 +10,7 @@ type QuantoInt128 is int128; CASTING //////////////////////////////////////////////////////////////*/ -using {Casting.unwrap, Casting.toUint} for QuantoInt128 global; +using {Casting.unwrap} for QuantoInt128 global; /*////////////////////////////////////////////////////////////// HELPERS diff --git a/src/Int128/USDInt128/Casting.sol b/src/Int128/USDInt128/Casting.sol index 6fe3be5..6feafdf 100644 --- a/src/Int128/USDInt128/Casting.sol +++ b/src/Int128/USDInt128/Casting.sol @@ -2,10 +2,6 @@ pragma solidity >=0.8.19; import {USDInt128} from "./ValueType.sol"; -import {USDUint128} from "../../Uint128/USDUint128/ValueType.sol"; -import {SafeCastI128} from "../../utils/SafeCast.sol"; - -using SafeCastI128 for int128; /// @notice Wraps a int128 number into the USDInt128 value type. function wrap(int128 x) pure returns (USDInt128 result) { @@ -16,8 +12,3 @@ function wrap(int128 x) pure returns (USDInt128 result) { function unwrap(USDInt128 x) pure returns (int128 result) { result = USDInt128.unwrap(x); } - -/// @notice Converts a USDInt128 number into USDUint128. -function toUint(USDInt128 x) pure returns (USDUint128 result) { - result = USDUint128.wrap(unwrap(x).toUint()); -} diff --git a/src/Int128/USDInt128/ValueType.sol b/src/Int128/USDInt128/ValueType.sol index f8dad05..c3f9790 100644 --- a/src/Int128/USDInt128/ValueType.sol +++ b/src/Int128/USDInt128/ValueType.sol @@ -10,7 +10,7 @@ type USDInt128 is int128; CASTING //////////////////////////////////////////////////////////////*/ -using {Casting.unwrap, Casting.toUint} for USDInt128 global; +using {Casting.unwrap} for USDInt128 global; /*////////////////////////////////////////////////////////////// HELPERS diff --git a/src/Int128/USDPerBaseInt128/Casting.sol b/src/Int128/USDPerBaseInt128/Casting.sol index 36000b4..c6b0a0a 100644 --- a/src/Int128/USDPerBaseInt128/Casting.sol +++ b/src/Int128/USDPerBaseInt128/Casting.sol @@ -2,10 +2,6 @@ pragma solidity >=0.8.19; import {USDPerBaseInt128} from "./ValueType.sol"; -import {USDPerBaseUint128} from "../../Uint128/USDPerBaseUint128/ValueType.sol"; -import {SafeCastI128} from "../../utils/SafeCast.sol"; - -using SafeCastI128 for int128; /// @notice Wraps a int128 number into the USDPerBaseInt128 value type. function wrap(int128 x) pure returns (USDPerBaseInt128 result) { @@ -16,8 +12,3 @@ function wrap(int128 x) pure returns (USDPerBaseInt128 result) { function unwrap(USDPerBaseInt128 x) pure returns (int128 result) { result = USDPerBaseInt128.unwrap(x); } - -/// @notice Converts a USDPerBaseInt128 number into USDPerBaseUint128. -function toUint(USDPerBaseInt128 x) pure returns (USDPerBaseUint128 result) { - result = USDPerBaseUint128.wrap(unwrap(x).toUint()); -} diff --git a/src/Int128/USDPerBaseInt128/ValueType.sol b/src/Int128/USDPerBaseInt128/ValueType.sol index 4d3df4f..774ce9a 100644 --- a/src/Int128/USDPerBaseInt128/ValueType.sol +++ b/src/Int128/USDPerBaseInt128/ValueType.sol @@ -10,7 +10,7 @@ type USDPerBaseInt128 is int128; CASTING //////////////////////////////////////////////////////////////*/ -using {Casting.unwrap, Casting.toUint} for USDPerBaseInt128 global; +using {Casting.unwrap} for USDPerBaseInt128 global; /*////////////////////////////////////////////////////////////// HELPERS diff --git a/src/Int128/USDPerQuantoInt128/Casting.sol b/src/Int128/USDPerQuantoInt128/Casting.sol index 3a64328..afba324 100644 --- a/src/Int128/USDPerQuantoInt128/Casting.sol +++ b/src/Int128/USDPerQuantoInt128/Casting.sol @@ -2,11 +2,6 @@ pragma solidity >=0.8.19; import {USDPerQuantoInt128} from "./ValueType.sol"; -import {USDPerQuantoUint128} from - "../../Uint128/USDPerQuantoUint128/ValueType.sol"; -import {SafeCastI128} from "../../utils/SafeCast.sol"; - -using SafeCastI128 for int128; /// @notice Wraps a int128 number into the USDPerQuantoInt128 value type. function wrap(int128 x) pure returns (USDPerQuantoInt128 result) { @@ -17,11 +12,3 @@ function wrap(int128 x) pure returns (USDPerQuantoInt128 result) { function unwrap(USDPerQuantoInt128 x) pure returns (int128 result) { result = USDPerQuantoInt128.unwrap(x); } - -/// @notice Converts a USDPerQuantoInt128 number into USDPerQuantoUint128. -function toUint(USDPerQuantoInt128 x) - pure - returns (USDPerQuantoUint128 result) -{ - result = USDPerQuantoUint128.wrap(unwrap(x).toUint()); -} diff --git a/src/Int128/USDPerQuantoInt128/ValueType.sol b/src/Int128/USDPerQuantoInt128/ValueType.sol index e013b16..37303f3 100644 --- a/src/Int128/USDPerQuantoInt128/ValueType.sol +++ b/src/Int128/USDPerQuantoInt128/ValueType.sol @@ -10,7 +10,7 @@ type USDPerQuantoInt128 is int128; CASTING //////////////////////////////////////////////////////////////*/ -using {Casting.unwrap, Casting.toUint} for USDPerQuantoInt128 global; +using {Casting.unwrap} for USDPerQuantoInt128 global; /*////////////////////////////////////////////////////////////// HELPERS diff --git a/src/Int256/BaseInt256/Casting.sol b/src/Int256/BaseInt256/Casting.sol index c6c65bd..d4d5c0a 100644 --- a/src/Int256/BaseInt256/Casting.sol +++ b/src/Int256/BaseInt256/Casting.sol @@ -3,7 +3,6 @@ pragma solidity >=0.8.19; import {BaseInt256} from "./ValueType.sol"; import {BaseInt128} from "../../Int128/BaseInt128/ValueType.sol"; -import {BaseUint256} from "../../Uint256/BaseUint256/ValueType.sol"; import {SafeCastI256} from "../../utils/SafeCast.sol"; using SafeCastI256 for int256; @@ -22,8 +21,3 @@ function unwrap(BaseInt256 x) pure returns (int256 result) { function to128(BaseInt256 x) pure returns (BaseInt128 result) { result = BaseInt128.wrap(unwrap(x).to128()); } - -/// @notice Converts a BaseInt256 number into BaseUint256. -function toUint(BaseInt256 x) pure returns (BaseUint256 result) { - result = BaseUint256.wrap(unwrap(x).toUint()); -} diff --git a/src/Int256/BaseInt256/ValueType.sol b/src/Int256/BaseInt256/ValueType.sol index 244b7e3..6513d1d 100644 --- a/src/Int256/BaseInt256/ValueType.sol +++ b/src/Int256/BaseInt256/ValueType.sol @@ -10,7 +10,7 @@ type BaseInt256 is int256; CASTING //////////////////////////////////////////////////////////////*/ -using {Casting.unwrap, Casting.to128, Casting.toUint} for BaseInt256 global; +using {Casting.unwrap, Casting.to128} for BaseInt256 global; /*////////////////////////////////////////////////////////////// HELPERS diff --git a/src/Int256/BaseQuantoPerUSDInt256/Casting.sol b/src/Int256/BaseQuantoPerUSDInt256/Casting.sol index 0bfcc39..86bf90d 100644 --- a/src/Int256/BaseQuantoPerUSDInt256/Casting.sol +++ b/src/Int256/BaseQuantoPerUSDInt256/Casting.sol @@ -4,8 +4,7 @@ pragma solidity >=0.8.19; import {BaseQuantoPerUSDInt256} from "./ValueType.sol"; import {BaseQuantoPerUSDInt128} from "../../Int128/BaseQuantoPerUSDInt128/ValueType.sol"; -import {BaseQuantoPerUSDUint256} from - "../../Uint256/BaseQuantoPerUSDUint256/ValueType.sol"; + import {SafeCastI256} from "../../utils/SafeCast.sol"; using SafeCastI256 for int256; @@ -27,11 +26,3 @@ function to128(BaseQuantoPerUSDInt256 x) { result = BaseQuantoPerUSDInt128.wrap(unwrap(x).to128()); } - -/// @notice Converts a BaseQuantoPerUSDInt256 number into BaseQuantoPerUSDUint256. -function toUint(BaseQuantoPerUSDInt256 x) - pure - returns (BaseQuantoPerUSDUint256 result) -{ - result = BaseQuantoPerUSDUint256.wrap(unwrap(x).toUint()); -} diff --git a/src/Int256/BaseQuantoPerUSDInt256/ValueType.sol b/src/Int256/BaseQuantoPerUSDInt256/ValueType.sol index fdb331f..ab62f79 100644 --- a/src/Int256/BaseQuantoPerUSDInt256/ValueType.sol +++ b/src/Int256/BaseQuantoPerUSDInt256/ValueType.sol @@ -12,8 +12,7 @@ type BaseQuantoPerUSDInt256 is int256; using { Casting.unwrap, - Casting.to128, - Casting.toUint + Casting.to128 } for BaseQuantoPerUSDInt256 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Int256/QuantoInt256/Casting.sol b/src/Int256/QuantoInt256/Casting.sol index 8e6d0e6..97a2bf9 100644 --- a/src/Int256/QuantoInt256/Casting.sol +++ b/src/Int256/QuantoInt256/Casting.sol @@ -3,7 +3,6 @@ pragma solidity >=0.8.19; import {QuantoInt256} from "./ValueType.sol"; import {QuantoInt128} from "../../Int128/QuantoInt128/ValueType.sol"; -import {QuantoUint256} from "../../Uint256/QuantoUint256/ValueType.sol"; import {SafeCastI256} from "../../utils/SafeCast.sol"; using SafeCastI256 for int256; @@ -22,8 +21,3 @@ function unwrap(QuantoInt256 x) pure returns (int256 result) { function to128(QuantoInt256 x) pure returns (QuantoInt128 result) { result = QuantoInt128.wrap(unwrap(x).to128()); } - -/// @notice Converts a QuantoInt256 number into QuantoUint256. -function toUint(QuantoInt256 x) pure returns (QuantoUint256 result) { - result = QuantoUint256.wrap(unwrap(x).toUint()); -} diff --git a/src/Int256/QuantoInt256/ValueType.sol b/src/Int256/QuantoInt256/ValueType.sol index a23ab0d..b6ea6b2 100644 --- a/src/Int256/QuantoInt256/ValueType.sol +++ b/src/Int256/QuantoInt256/ValueType.sol @@ -11,7 +11,7 @@ type QuantoInt256 is int256; //////////////////////////////////////////////////////////////*/ using { - Casting.unwrap, Casting.to128, Casting.toUint + Casting.unwrap, Casting.to128 } for QuantoInt256 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Int256/USDInt256/Casting.sol b/src/Int256/USDInt256/Casting.sol index f1c766b..6c111f9 100644 --- a/src/Int256/USDInt256/Casting.sol +++ b/src/Int256/USDInt256/Casting.sol @@ -3,7 +3,6 @@ pragma solidity >=0.8.19; import {USDInt256} from "./ValueType.sol"; import {USDInt128} from "../../Int128/USDInt128/ValueType.sol"; -import {USDUint256} from "../../Uint256/USDUint256/ValueType.sol"; import {SafeCastI256} from "../../utils/SafeCast.sol"; using SafeCastI256 for int256; @@ -22,8 +21,3 @@ function unwrap(USDInt256 x) pure returns (int256 result) { function to128(USDInt256 x) pure returns (USDInt128 result) { result = USDInt128.wrap(unwrap(x).to128()); } - -/// @notice Converts a USDInt256 number into USDUint256. -function toUint(USDInt256 x) pure returns (USDUint256 result) { - result = USDUint256.wrap(unwrap(x).toUint()); -} diff --git a/src/Int256/USDInt256/ValueType.sol b/src/Int256/USDInt256/ValueType.sol index 15fc273..958fe57 100644 --- a/src/Int256/USDInt256/ValueType.sol +++ b/src/Int256/USDInt256/ValueType.sol @@ -10,7 +10,7 @@ type USDInt256 is int256; CASTING //////////////////////////////////////////////////////////////*/ -using {Casting.unwrap, Casting.to128, Casting.toUint} for USDInt256 global; +using {Casting.unwrap, Casting.to128} for USDInt256 global; /*////////////////////////////////////////////////////////////// HELPERS diff --git a/src/Int256/USDPerBaseInt256/Casting.sol b/src/Int256/USDPerBaseInt256/Casting.sol index ea79243..aa30049 100644 --- a/src/Int256/USDPerBaseInt256/Casting.sol +++ b/src/Int256/USDPerBaseInt256/Casting.sol @@ -3,7 +3,6 @@ pragma solidity >=0.8.19; import {USDPerBaseInt256} from "./ValueType.sol"; import {USDPerBaseInt128} from "../../Int128/USDPerBaseInt128/ValueType.sol"; -import {USDPerBaseUint256} from "../../Uint256/USDPerBaseUint256/ValueType.sol"; import {SafeCastI256} from "../../utils/SafeCast.sol"; using SafeCastI256 for int256; @@ -22,8 +21,3 @@ function unwrap(USDPerBaseInt256 x) pure returns (int256 result) { function to128(USDPerBaseInt256 x) pure returns (USDPerBaseInt128 result) { result = USDPerBaseInt128.wrap(unwrap(x).to128()); } - -/// @notice Converts a USDPerBaseInt256 number into USDPerBaseUint256. -function toUint(USDPerBaseInt256 x) pure returns (USDPerBaseUint256 result) { - result = USDPerBaseUint256.wrap(unwrap(x).toUint()); -} diff --git a/src/Int256/USDPerBaseInt256/ValueType.sol b/src/Int256/USDPerBaseInt256/ValueType.sol index 4a28c1e..4ae9bff 100644 --- a/src/Int256/USDPerBaseInt256/ValueType.sol +++ b/src/Int256/USDPerBaseInt256/ValueType.sol @@ -12,8 +12,7 @@ type USDPerBaseInt256 is int256; using { Casting.unwrap, - Casting.to128, - Casting.toUint + Casting.to128 } for USDPerBaseInt256 global; /*////////////////////////////////////////////////////////////// diff --git a/src/Int256/USDPerQuantoInt256/Casting.sol b/src/Int256/USDPerQuantoInt256/Casting.sol index 9d0f03e..6d1fa00 100644 --- a/src/Int256/USDPerQuantoInt256/Casting.sol +++ b/src/Int256/USDPerQuantoInt256/Casting.sol @@ -3,8 +3,6 @@ pragma solidity >=0.8.19; import {USDPerQuantoInt256} from "./ValueType.sol"; import {USDPerQuantoInt128} from "../../Int128/USDPerQuantoInt128/ValueType.sol"; -import {USDPerQuantoUint256} from - "../../Uint256/USDPerQuantoUint256/ValueType.sol"; import {SafeCastI256} from "../../utils/SafeCast.sol"; using SafeCastI256 for int256; @@ -23,11 +21,3 @@ function unwrap(USDPerQuantoInt256 x) pure returns (int256 result) { function to128(USDPerQuantoInt256 x) pure returns (USDPerQuantoInt128 result) { result = USDPerQuantoInt128.wrap(unwrap(x).to128()); } - -/// @notice Converts a USDPerQuantoInt256 number into USDPerQuantoUint256. -function toUint(USDPerQuantoInt256 x) - pure - returns (USDPerQuantoUint256 result) -{ - result = USDPerQuantoUint256.wrap(unwrap(x).toUint()); -} diff --git a/src/Int256/USDPerQuantoInt256/ValueType.sol b/src/Int256/USDPerQuantoInt256/ValueType.sol index 00b1721..e57845b 100644 --- a/src/Int256/USDPerQuantoInt256/ValueType.sol +++ b/src/Int256/USDPerQuantoInt256/ValueType.sol @@ -12,8 +12,7 @@ type USDPerQuantoInt256 is int256; using { Casting.unwrap, - Casting.to128, - Casting.toUint + Casting.to128 } for USDPerQuantoInt256 global; /*////////////////////////////////////////////////////////////// diff --git a/test/Int128/BaseInt128.t.sol b/test/Int128/BaseInt128.t.sol index 107f197..280bfca 100644 --- a/test/Int128/BaseInt128.t.sol +++ b/test/Int128/BaseInt128.t.sol @@ -4,7 +4,6 @@ pragma solidity >=0.8.19; import {Test, console} from "forge-std/Test.sol"; import { BaseInt128, - BaseUint128, USDPerBaseInt128, USDInt128 } from "../../src/UnitTypes.sol"; @@ -352,23 +351,4 @@ contract BaseInt128Test is Test { assertEq(result.unwrap(), z); } } - - function testBaseInt128ToUint() public { - int128 x = type(int128).min; - vm.expectRevert(); - BaseInt128.wrap(x).toUint(); - x = 1; - BaseUint128 result = BaseInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - - function testBaseInt128ToUintFuzz(int128 x) public { - if (x < 0) { - vm.expectRevert(); - BaseInt128.wrap(x).toUint(); - } else { - BaseUint128 result = BaseInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - } } diff --git a/test/Int128/BaseQuantoPerUSDInt128.t.sol b/test/Int128/BaseQuantoPerUSDInt128.t.sol index dcc9035..ce22c1a 100644 --- a/test/Int128/BaseQuantoPerUSDInt128.t.sol +++ b/test/Int128/BaseQuantoPerUSDInt128.t.sol @@ -4,7 +4,6 @@ pragma solidity >=0.8.19; import {Test, console} from "forge-std/Test.sol"; import { BaseQuantoPerUSDInt128, - BaseQuantoPerUSDUint128, BaseInt128, QuantoInt128, USDPerBaseInt128, @@ -411,24 +410,4 @@ contract BaseQuantoPerUSDInt128Test is Test { assertEq(result.unwrap(), z); } } - - function testBaseQuantoPerUSDInt128ToUint() public { - int128 x = type(int128).min; - vm.expectRevert(); - BaseQuantoPerUSDInt128.wrap(x).toUint(); - x = 1; - BaseQuantoPerUSDUint128 result = BaseQuantoPerUSDInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - - function testBaseQuantoPerUSDInt128ToUintFuzz(int128 x) public { - if (x < 0) { - vm.expectRevert(); - BaseQuantoPerUSDInt128.wrap(x).toUint(); - } else { - BaseQuantoPerUSDUint128 result = - BaseQuantoPerUSDInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - } } diff --git a/test/Int128/QuantoInt128.t.sol b/test/Int128/QuantoInt128.t.sol index ec2e929..aa605bf 100644 --- a/test/Int128/QuantoInt128.t.sol +++ b/test/Int128/QuantoInt128.t.sol @@ -4,7 +4,6 @@ pragma solidity >=0.8.19; import {Test, console} from "forge-std/Test.sol"; import { QuantoInt128, - QuantoUint128, USDPerQuantoInt128, USDInt128 } from "../../src/UnitTypes.sol"; @@ -354,23 +353,4 @@ contract QuantoInt128Test is Test { assertEq(result.unwrap(), z); } } - - function testQuantoInt128ToUint() public { - int128 x = type(int128).min; - vm.expectRevert(); - QuantoInt128.wrap(x).toUint(); - x = 1; - QuantoUint128 result = QuantoInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - - function testQuantoInt128ToUintFuzz(int128 x) public { - if (x < 0) { - vm.expectRevert(); - QuantoInt128.wrap(x).toUint(); - } else { - QuantoUint128 result = QuantoInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - } } diff --git a/test/Int128/USDInt128.t.sol b/test/Int128/USDInt128.t.sol index 63e9462..5b9bc03 100644 --- a/test/Int128/USDInt128.t.sol +++ b/test/Int128/USDInt128.t.sol @@ -2,7 +2,7 @@ pragma solidity >=0.8.19; import {Test, console} from "forge-std/Test.sol"; -import {USDInt128, USDUint128} from "../../src/UnitTypes.sol"; +import {USDInt128} from "../../src/UnitTypes.sol"; contract USDInt128Test is Test { function setUp() public {} @@ -318,23 +318,4 @@ contract USDInt128Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDInt128ToUint() public { - int128 x = type(int128).min; - vm.expectRevert(); - USDInt128.wrap(x).toUint(); - x = 1; - USDUint128 result = USDInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - - function testUSDInt128ToUintFuzz(int128 x) public { - if (x < 0) { - vm.expectRevert(); - USDInt128.wrap(x).toUint(); - } else { - USDUint128 result = USDInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - } } diff --git a/test/Int128/USDPerBaseInt128.t.sol b/test/Int128/USDPerBaseInt128.t.sol index 78ce40f..40ac042 100644 --- a/test/Int128/USDPerBaseInt128.t.sol +++ b/test/Int128/USDPerBaseInt128.t.sol @@ -7,7 +7,6 @@ import { BaseInt128, QuantoInt128, USDPerBaseInt128, - USDPerBaseUint128, USDInt128 } from "../../src/UnitTypes.sol"; @@ -396,23 +395,4 @@ contract USDPerBaseInt128Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDPerBaseInt128ToUint() public { - int128 x = type(int128).min; - vm.expectRevert(); - USDPerBaseInt128.wrap(x).toUint(); - x = 1; - USDPerBaseUint128 result = USDPerBaseInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - - function testUSDPerBaseInt128ToUintFuzz(int128 x) public { - if (x < 0) { - vm.expectRevert(); - USDPerBaseInt128.wrap(x).toUint(); - } else { - USDPerBaseUint128 result = USDPerBaseInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - } } diff --git a/test/Int128/USDPerQuantoInt128.t.sol b/test/Int128/USDPerQuantoInt128.t.sol index a17d465..4293fae 100644 --- a/test/Int128/USDPerQuantoInt128.t.sol +++ b/test/Int128/USDPerQuantoInt128.t.sol @@ -7,7 +7,6 @@ import { QuantoInt128, BaseInt128, USDPerQuantoInt128, - USDPerQuantoUint128, USDInt128 } from "../../src/UnitTypes.sol"; @@ -396,23 +395,4 @@ contract USDPerQuantoInt128Test is Test { assertEq(result.unwrap(), z); } } - - function testUSDPerQuantoInt128ToUint() public { - int128 x = type(int128).min; - vm.expectRevert(); - USDPerQuantoInt128.wrap(x).toUint(); - x = 1; - USDPerQuantoUint128 result = USDPerQuantoInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - - function testUSDPerQuantoInt128ToUintFuzz(int128 x) public { - if (x < 0) { - vm.expectRevert(); - USDPerQuantoInt128.wrap(x).toUint(); - } else { - USDPerQuantoUint128 result = USDPerQuantoInt128.wrap(x).toUint(); - assertEq(result.unwrap(), uint128(x)); - } - } } diff --git a/test/Int256/BaseInt256.t.sol b/test/Int256/BaseInt256.t.sol index 30a8282..badd4d6 100644 --- a/test/Int256/BaseInt256.t.sol +++ b/test/Int256/BaseInt256.t.sol @@ -6,7 +6,6 @@ import { BaseQuantoPerUSDInt256, BaseInt256, BaseInt128, - BaseUint256, QuantoInt256, USDPerBaseInt256, USDPerQuantoInt256, @@ -375,23 +374,4 @@ contract BaseInt256Test is Test { assertEq(result.unwrap(), int128(x)); } } - - function testBaseInt256ToUint() public { - int256 x = type(int256).min; - vm.expectRevert(); - BaseInt256.wrap(x).toUint(); - x = 1; - BaseUint256 result = BaseInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - - function testBaseInt256ToUintFuzz(int256 x) public { - if (x < 0) { - vm.expectRevert(); - BaseInt256.wrap(x).toUint(); - } else { - BaseUint256 result = BaseInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - } } diff --git a/test/Int256/BaseQuantoPerUSDInt256.t.sol b/test/Int256/BaseQuantoPerUSDInt256.t.sol index c4077a9..094b370 100644 --- a/test/Int256/BaseQuantoPerUSDInt256.t.sol +++ b/test/Int256/BaseQuantoPerUSDInt256.t.sol @@ -5,7 +5,6 @@ import {Test, console} from "forge-std/Test.sol"; import { BaseQuantoPerUSDInt256, BaseQuantoPerUSDInt128, - BaseQuantoPerUSDUint256, BaseInt256, QuantoInt256, USDPerBaseInt256, @@ -433,24 +432,4 @@ contract BaseQuantoPerUSDInt256Test is Test { assertEq(result.unwrap(), int128(x)); } } - - function testBaseQuantoPerUSDInt256ToUint() public { - int256 x = type(int256).min; - vm.expectRevert(); - BaseQuantoPerUSDInt256.wrap(x).toUint(); - x = 1; - BaseQuantoPerUSDUint256 result = BaseQuantoPerUSDInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - - function testBaseQuantoPerUSDInt256ToUintFuzz(int256 x) public { - if (x < 0) { - vm.expectRevert(); - BaseQuantoPerUSDInt256.wrap(x).toUint(); - } else { - BaseQuantoPerUSDUint256 result = - BaseQuantoPerUSDInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - } } diff --git a/test/Int256/QuantoInt256.t.sol b/test/Int256/QuantoInt256.t.sol index fffda93..cbc0a32 100644 --- a/test/Int256/QuantoInt256.t.sol +++ b/test/Int256/QuantoInt256.t.sol @@ -7,7 +7,6 @@ import { BaseInt256, QuantoInt256, QuantoInt128, - QuantoUint256, USDPerBaseInt256, USDPerQuantoInt256, USDInt256 @@ -377,23 +376,4 @@ contract QuantoInt256Test is Test { assertEq(result.unwrap(), int128(x)); } } - - function testQuantoInt256ToUint() public { - int256 x = type(int256).min; - vm.expectRevert(); - QuantoInt256.wrap(x).toUint(); - x = 1; - QuantoUint256 result = QuantoInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - - function testQuantoInt256ToUintFuzz(int256 x) public { - if (x < 0) { - vm.expectRevert(); - QuantoInt256.wrap(x).toUint(); - } else { - QuantoUint256 result = QuantoInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - } } diff --git a/test/Int256/USDInt256.t.sol b/test/Int256/USDInt256.t.sol index c19405a..1ed79e2 100644 --- a/test/Int256/USDInt256.t.sol +++ b/test/Int256/USDInt256.t.sol @@ -9,8 +9,7 @@ import { USDPerBaseInt256, USDPerQuantoInt256, USDInt256, - USDInt128, - USDUint256 + USDInt128 } from "../../src/UnitTypes.sol"; contract USDInt256Test is Test { @@ -346,23 +345,4 @@ contract USDInt256Test is Test { assertEq(result.unwrap(), int128(x)); } } - - function testUSDInt256ToUint() public { - int256 x = type(int256).min; - vm.expectRevert(); - USDInt256.wrap(x).toUint(); - x = 1; - USDUint256 result = USDInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - - function testUSDInt256ToUintFuzz(int256 x) public { - if (x < 0) { - vm.expectRevert(); - USDInt256.wrap(x).toUint(); - } else { - USDUint256 result = USDInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - } } diff --git a/test/Int256/USDPerBaseInt256.t.sol b/test/Int256/USDPerBaseInt256.t.sol index 11c6db5..6cb075b 100644 --- a/test/Int256/USDPerBaseInt256.t.sol +++ b/test/Int256/USDPerBaseInt256.t.sol @@ -8,7 +8,6 @@ import { QuantoInt256, USDPerBaseInt256, USDPerBaseInt128, - USDPerBaseUint256, USDPerQuantoInt256, USDInt256 } from "../../src/UnitTypes.sol"; @@ -417,23 +416,4 @@ contract USDPerBaseInt256Test is Test { assertEq(result.unwrap(), int128(x)); } } - - function testUSDPerBaseInt256ToUint() public { - int256 x = type(int256).min; - vm.expectRevert(); - USDPerBaseInt256.wrap(x).toUint(); - x = 1; - USDPerBaseUint256 result = USDPerBaseInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - - function testUSDPerBaseInt256ToUintFuzz(int256 x) public { - if (x < 0) { - vm.expectRevert(); - USDPerBaseInt256.wrap(x).toUint(); - } else { - USDPerBaseUint256 result = USDPerBaseInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - } } diff --git a/test/Int256/USDPerQuantoInt256.t.sol b/test/Int256/USDPerQuantoInt256.t.sol index f4db2da..6f1bbe3 100644 --- a/test/Int256/USDPerQuantoInt256.t.sol +++ b/test/Int256/USDPerQuantoInt256.t.sol @@ -9,7 +9,6 @@ import { USDPerBaseInt256, USDPerQuantoInt256, USDPerQuantoInt128, - USDPerQuantoUint256, USDInt256 } from "../../src/UnitTypes.sol"; @@ -417,23 +416,4 @@ contract USDPerQuantoInt256Test is Test { assertEq(result.unwrap(), int128(x)); } } - - function testUSDPerQuantoInt256ToUint() public { - int256 x = type(int256).min; - vm.expectRevert(); - USDPerQuantoInt256.wrap(x).toUint(); - x = 1; - USDPerQuantoUint256 result = USDPerQuantoInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - - function testUSDPerQuantoInt256ToUintFuzz(int256 x) public { - if (x < 0) { - vm.expectRevert(); - USDPerQuantoInt256.wrap(x).toUint(); - } else { - USDPerQuantoUint256 result = USDPerQuantoInt256.wrap(x).toUint(); - assertEq(result.unwrap(), uint256(x)); - } - } }