Description:
Multi-signature wallet contract requiring multiple confirmations for transaction execution.
Blockchain: Ethereum
Source Code: View Code On The Blockchain
Solidity Source Code:
{{
"language": "Solidity",
"sources": {
"src/pendle/PendleStrategyV2.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity 0.8.22;
import { IERC20, IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "@pendle/interfaces/IPAllActionV3.sol";
import { IPMarket, IPYieldToken, IStandardizedYield } from "@pendle/interfaces/IPMarket.sol";
import { PendleLpOracleLib } from "@pendle/oracles/PendleLpOracleLib.sol";
import { OperationsLib } from "../libraries/OperationsLib.sol";
import { StrategyConfigLib } from "../libraries/StrategyConfigLib.sol";
import { IHolding } from "@jigsaw/src/interfaces/core/IHolding.sol";
import { IManager } from "@jigsaw/src/interfaces/core/IManager.sol";
import { IReceiptToken } from "@jigsaw/src/interfaces/core/IReceiptToken.sol";
import { IStrategy } from "@jigsaw/src/interfaces/core/IStrategy.sol";
import { IStakerLight } from "../staker/interfaces/IStakerLight.sol";
import { IStakerLightFactory } from "../staker/interfaces/IStakerLightFactory.sol";
import { StrategyBaseUpgradeableV2 } from "../StrategyBaseUpgradeableV2.sol";
import { IFeeManager } from "../extensions/interfaces/IFeeManager.sol";
/**
* @title PendleStrategyV2
* @dev Strategy used for investments into Pendle strategy.
* @author Hovooo (@hovooo)
* @custom:oz-upgrades-from PendleStrategy
*/
contract PendleStrategyV2 is IStrategy, StrategyBaseUpgradeableV2 {
using SafeERC20 for IERC20;
using SafeCast for uint256;
using Math for uint256;
using PendleLpOracleLib for IPMarket;
/**
* @notice Struct containing parameters for a deposit operation.
* @param minLpOut The minimum amount of LP tokens to receive
* @param guessPtReceivedFromSy The estimated amount of PT received from the strategy
* @param input The input parameters for the pendleRouter addLiquiditySingleToken function
* @param limit The limit parameters for the pendleRouter addLiquiditySingleToken function
*/
struct DepositParams {
uint256 minLpOut;
ApproxParams guessPtReceivedFromSy;
TokenInput input;
LimitOrderData limit;
}
// -- Events --
/**
* @notice Emitted when the slippage percentage is updated.
* @param oldValue The previous slippage percentage value.
* @param newValue The new slippage percentage value.
*/
event SlippagePercentageSet(uint256 oldValue, uint256 newValue);
// -- Errors --
error InvalidTokenIn();
error InvalidTokenOut();
error PendleSwapNotEmpty();
error SwapDataNotEmpty();
/**
* @notice The specified minimum LP tokens out is less than the minimum allowed LP tokens out.
* @param minLpOut The specified minimum LP tokens out provided.
* @param minAllowedLpOut The minimum allowed LP tokens out.
*/
error InvalidMinLpOut(uint256 minLpOut, uint256 minAllowedLpOut);
/**
* @notice The specified minimum token out is less than the minimum allowed token out.
* @param minTokenOut The specified minimum token out provided.
* @param minAllowedTokenOut The minimum allowed token out.
*/
error InvalidMinTokenOut(uint256 minTokenOut, uint256 minAllowedTokenOut);
// -- Custom types --
/**
* @notice Struct for the initializer params.
* @param owner The address of the initial owner of the Strategy contract
* @param manager The address of the Manager contract
* @param pendleRouter The address of the Pendle's Router contract
* @param pendleMarket The address of the Pendle's Market contract used for strategy
* @param stakerFactory The address of the StakerLightFactory contract
* @param jigsawRewardToken The address of the Jigsaw reward token associated with the strategy
* @param jigsawRewardDuration The address of the initial Jigsaw reward distribution duration for the strategy
* @param tokenIn The address of the LP token
* @param tokenOut The address of the Pendle receipt token
* @param rewardToken The address of the Pendle primary reward token
*/
struct InitializerParams {
address owner;
address manager;
address pendleRouter;
address pendleMarket;
address stakerFactory;
address jigsawRewardToken;
uint256 jigsawRewardDuration;
address tokenIn;
address tokenOut;
address rewardToken;
}
/**
* @notice Struct for the reinitializer params.
* @param feeManager The address of the feeManager contract
*/
struct ReinitializerParams {
address feeManager;
}
// -- State variables --
/**
* @notice The tokenIn address for the strategy.
*/
address public override tokenIn;
/**
* @notice The tokenOut address for the strategy.
*/
address public override tokenOut;
/**
* @notice The Pendle's reward token offered to users.
*/
address public override rewardToken;
/**
* @notice The receipt token associated with this strategy.
*/
IReceiptToken public override receiptToken;
/**
* @notice The Pendle's Router contract.
*/
IPAllActionV3 public pendleRouter;
/**
* @notice The Pendle's PegStabilityModule contract.
*/
address public pendleMarket;
/**
* @notice The Jigsaw Rewards Controller contract.
*/
IStakerLight public jigsawStaker;
/**
* @notice The number of decimals of the strategy's shares.
*/
uint256 public override sharesDecimals;
/**
* @notice The empty limit order data.
*/
LimitOrderData public EMPTY_LIMIT_ORDER_DATA;
/**
* @notice The keccak256 hash of the empty limit order data.
*/
bytes32 public EMPTY_SWAP_DATA_HASH;
/**
* @notice Returns the maximum allowed slippage percentage.
* @dev Uses 2 decimal precision, where 1% is represented as 100.
*/
uint256 public allowedSlippagePercentage;
/**
* @notice The slippage factor.
*/
uint256 public constant SLIPPAGE_PRECISION = 1e4;
/**
* @notice The precision used for the Pendle LP price.
*/
uint256 public constant PENDLE_LP_PRICE_PRECISION = 1e18;
/**
* @notice A mapping that stores participant details by address.
*/
mapping(address recipient => IStrategy.RecipientInfo info) public override recipients;
// -- Constructor --
constructor() {
_disableInitializers();
}
// -- Initialization --
/**
* @notice Initializes the Pendle Strategy contract with necessary parameters.
*
* @dev Configures core components such as manager, tokens, pools, and reward systems
* needed for the strategy to operate.
*
* @dev This function is only callable once due to the `initializer` modifier.
*
* @notice Ensures that critical addresses are non-zero to prevent misconfiguration:
* - `_params.manager` must be valid (`"3065"` error code if invalid).
* - `_params.pendleRouter` must be valid (`"3036"` error code if invalid).
* - `_params.pendleMarket` must be valid (`"3036"` error code if invalid).
* - `_params.tokenIn` and `_params.tokenOut` must be valid (`"3000"` error code if invalid).
* - `_params.rewardToken` must be valid (`"3000"` error code if invalid).
*
* @param _params Struct containing all initialization parameters.
*/
function initialize(
InitializerParams memory _params
) public initializer {
require(_params.manager != address(0), "3065");
require(_params.pendleRouter != address(0), "3036");
require(_params.pendleMarket != address(0), "3036");
require(_params.tokenIn != address(0), "3000");
require(_params.tokenOut != address(0), "3000");
require(_params.rewardToken != address(0), "3000");
__StrategyBase_init({ _initialOwner: _params.owner });
manager = IManager(_params.manager);
pendleRouter = IPAllActionV3(_params.pendleRouter);
pendleMarket = _params.pendleMarket;
tokenIn = _params.tokenIn;
tokenOut = _params.tokenOut;
rewardToken = _params.rewardToken;
sharesDecimals = IERC20Metadata(_params.tokenOut).decimals();
EMPTY_SWAP_DATA_HASH = 0x95e00231cb51f973e9db40dd7466e602a0dcf1466ba8363089a90b5cb5416a27;
// Set default allowed slippage percentage to 5%
_setSlippagePercentage({ _newVal: 500 });
receiptToken = IReceiptToken(
StrategyConfigLib.configStrategy({
_initialOwner: _params.owner,
_receiptTokenFactory: manager.receiptTokenFactory(),
_receiptTokenName: "Pendle Receipt Token",
_receiptTokenSymbol: "PeRT"
})
);
jigsawStaker = IStakerLight(
IStakerLightFactory(_params.stakerFactory).createStakerLight({
_initialOwner: _params.owner,
_holdingManager: manager.holdingManager(),
_rewardToken: _params.jigsawRewardToken,
_strategy: address(this),
_rewardsDuration: _params.jigsawRewardDuration
})
);
}
/**
* @custom:oz-upgrades-validate-as-initializer
*
* @notice Initializes the Aave Strategy V2 contract with necessary parameters.
*
* @dev Configures core components such as manager, tokens, pools, and reward systems
* needed for the strategy to operate.
*
* @dev This function is only callable once due to the `initializer` modifier.
*
* @notice Ensures that critical addresses are non-zero to prevent misconfiguration:
* - `_params.feeManager` must be valid (`"3000"` error code if invalid).
*
* @param _params Struct containing all initialization parameters.
*/
function reinitialize(
ReinitializerParams memory _params
) public reinitializer(2) {
require(_params.feeManager != address(0), "3000");
feeManager = IFeeManager(_params.feeManager);
}
// -- User-specific Methods --
/**
* @notice Deposits funds into the strategy.
*
* @param _asset The token to be invested.
* @param _amount The amount of the token to be invested.
* @param _recipient The address on behalf of which the funds are deposited.
* @param _data The data containing the deposit parameters.
*
* @return The amount of receipt tokens obtained.
* @return The amount of the 'tokenIn()' token.
*/
function deposit(
address _asset,
uint256 _amount,
address _recipient,
bytes calldata _data
) external override nonReentrant onlyValidAmount(_amount) onlyStrategyManager returns (uint256, uint256) {
require(_asset == tokenIn, "3001");
DepositParams memory params;
(params.minLpOut, params.guessPtReceivedFromSy, params.input) =
abi.decode(_data, (uint256, ApproxParams, TokenInput));
require(params.input.tokenIn == tokenIn, "3001");
require(params.input.netTokenIn == _amount, "2001");
if (params.input.pendleSwap != address(0)) revert PendleSwapNotEmpty();
if (params.input.tokenMintSy != tokenIn) revert InvalidTokenIn();
if (keccak256(abi.encode(params.input.swapData)) != EMPTY_SWAP_DATA_HASH) revert SwapDataNotEmpty();
if (params.minLpOut < getMinAllowedLpOut({ _amount: _amount })) {
revert InvalidMinLpOut({
minLpOut: params.minLpOut,
minAllowedLpOut: getMinAllowedLpOut({ _amount: _amount })
});
}
IHolding(_recipient).transfer({ _token: _asset, _to: address(this), _amount: _amount });
uint256 balanceBefore = IERC20(tokenOut).balanceOf(_recipient);
IERC20(_asset).forceApprove({ spender: address(pendleRouter), value: _amount });
pendleRouter.addLiquiditySingleToken({
receiver: _recipient,
market: pendleMarket,
minLpOut: params.minLpOut,
guessPtReceivedFromSy: params.guessPtReceivedFromSy,
input: params.input,
limit: EMPTY_LIMIT_ORDER_DATA
});
uint256 shares = IERC20(tokenOut).balanceOf(_recipient) - balanceBefore;
recipients[_recipient].investedAmount += _amount;
recipients[_recipient].totalShares += shares;
_mint({ _receiptToken: receiptToken, _recipient: _recipient, _amount: shares, _tokenDecimals: sharesDecimals });
jigsawStaker.deposit({ _user: _recipient, _amount: shares });
emit Deposit({
asset: _asset,
tokenIn: tokenIn,
assetAmount: _amount,
tokenInAmount: _amount,
shares: shares,
recipient: _recipient
});
return (shares, _amount);
}
/**
* @notice Withdraws deposited funds from the strategy.
*
* @param _shares The amount of shares to withdraw.
* @param _recipient The address on behalf of which the funds are withdrawn.
* @param _asset The token to be withdrawn.
* @param _data The data containing the token output .
*
* @return withdrawnAmount The actual amount of asset withdrawn from the strategy.
* @return initialInvestment The amount of initial investment.
* @return yield The amount of yield generated by the user beyond their initial investment.
* @return fee The amount of fee charged by the strategy.
*/
function withdraw(
uint256 _shares,
address _recipient,
address _asset,
bytes calldata _data
) external override nonReentrant onlyStrategyManager returns (uint256, uint256, int256, uint256) {
require(_asset == tokenIn, "3001");
require(_shares <= IERC20(tokenOut).balanceOf(_recipient), "2002");
WithdrawParams memory params = WithdrawParams({
shares: _shares,
totalShares: recipients[_recipient].totalShares,
shareRatio: 0,
shareDecimals: sharesDecimals,
investment: 0,
assetsToWithdraw: 0, // not used in Pendle strategy
balanceBefore: 0,
withdrawnAmount: 0,
yield: 0,
fee: 0
});
// Decode pendle's output params used for removeLiquiditySingleToken.
TokenOutput memory output = abi.decode(_data, (TokenOutput));
if (output.pendleSwap != address(0)) revert PendleSwapNotEmpty();
if (output.tokenOut != tokenIn || output.tokenRedeemSy != tokenIn) revert InvalidTokenOut();
if (keccak256(abi.encode(output.swapData)) != EMPTY_SWAP_DATA_HASH) revert SwapDataNotEmpty();
params.shareRatio = OperationsLib.getRatio({
numerator: params.shares,
denominator: params.totalShares,
precision: params.shareDecimals,
rounding: OperationsLib.Rounding.Floor
});
_burn({
_receiptToken: receiptToken,
_recipient: _recipient,
_shares: params.shares,
_totalShares: params.totalShares,
_tokenDecimals: params.shareDecimals
});
// To accurately compute the protocol's fees from the yield generated by the strategy, we first need to
// determine the percentage of the initial investment being withdrawn. This allows us to assess whether any
// yield has been generated beyond the initial investment.
params.investment = (recipients[_recipient].investedAmount * params.shareRatio) / (10 ** params.shareDecimals);
params.balanceBefore = IERC20(tokenIn).balanceOf(_recipient);
uint256 minAllowedTokenOut = getMinAllowedTokenOut({ _amount: _shares });
if (output.minTokenOut < minAllowedTokenOut) {
revert InvalidMinTokenOut({ minTokenOut: output.minTokenOut, minAllowedTokenOut: minAllowedTokenOut });
}
IHolding(_recipient).approve({
_tokenAddress: tokenOut,
_destination: address(pendleRouter),
_amount: params.shares
});
_genericCall({
_holding: _recipient,
_contract: address(pendleRouter),
_call: abi.encodeCall(
IPActionAddRemoveLiqV3.removeLiquiditySingleToken,
(_recipient, pendleMarket, params.shares, output, EMPTY_LIMIT_ORDER_DATA)
)
});
// Take protocol's fee from generated yield if any.
params.withdrawnAmount = IERC20(tokenIn).balanceOf(_recipient) - params.balanceBefore;
params.yield = params.withdrawnAmount.toInt256() - params.investment.toInt256();
// Take protocol's fee from generated yield if any.
if (params.yield > 0) {
params.fee = _takePerformanceFee({ _token: tokenIn, _recipient: _recipient, _yield: uint256(params.yield) });
if (params.fee > 0) {
params.withdrawnAmount -= params.fee;
params.yield -= params.fee.toInt256();
}
}
recipients[_recipient].totalShares -= params.shares;
recipients[_recipient].investedAmount = params.investment > recipients[_recipient].investedAmount
? 0
: recipients[_recipient].investedAmount - params.investment;
emit Withdraw({
asset: _asset,
recipient: _recipient,
shares: params.shares,
withdrawnAmount: params.withdrawnAmount,
initialInvestment: params.investment,
yield: params.yield
});
// Register `_recipient`'s withdrawal operation to stop generating jigsaw rewards.
jigsawStaker.withdraw({ _user: _recipient, _amount: params.shares });
return (params.withdrawnAmount, params.investment, params.yield, params.fee);
}
/**
* @notice Claims rewards from the Pendle Pool.
* @return claimedAmounts The amounts of rewards claimed.
* @return rewardsList The addresses of the reward tokens.
*/
function claimRewards(
address _recipient,
bytes calldata
)
external
override
nonReentrant
onlyStrategyManager
returns (uint256[] memory claimedAmounts, address[] memory rewardsList)
{
(, bytes memory returnData) = _genericCall({
_holding: _recipient,
_contract: pendleMarket,
_call: abi.encodeCall(IPMarket.redeemRewards, _recipient)
});
// Get Pendle data.
rewardsList = IPMarket(pendleMarket).getRewardTokens();
claimedAmounts = abi.decode(returnData, (uint256[]));
for (uint256 i = 0; i < claimedAmounts.length; i++) {
// Take protocol fee for all non zero rewards.
if (claimedAmounts[i] != 0) {
uint256 fee =
_takePerformanceFee({ _token: rewardsList[i], _recipient: _recipient, _yield: claimedAmounts[i] });
if (fee > 0) claimedAmounts[i] -= fee;
}
}
emit Rewards({ recipient: _recipient, rewards: claimedAmounts, rewardTokens: rewardsList });
return (claimedAmounts, rewardsList);
}
// -- Administration --
function setSlippagePercentage(
uint256 _newVal
) external onlyOwner {
_setSlippagePercentage({ _newVal: _newVal });
}
// -- Getters --
/**
* @notice Returns the address of the receipt token.
*/
function getReceiptTokenAddress() external view override returns (address) {
return address(receiptToken);
}
/**
* @notice Calculates the minimum acceptable LP tokens received based on input amount and slippage tolerance.
* @dev Uses median of different timeframe rates to get a more stable price.
* @param _amount The amount of input tokens.
* @return The minimum acceptable LP tokens for the specified input amount.
*/
function getMinAllowedLpOut(
uint256 _amount
) public view returns (uint256) {
uint256 tokenInDecimals = IERC20Metadata(tokenIn).decimals();
uint256 normalizedAmount = _amount;
if (tokenInDecimals < 18) {
normalizedAmount = _amount * (10 ** (18 - tokenInDecimals));
} else if (tokenInDecimals > 18) {
normalizedAmount = _amount / (10 ** (tokenInDecimals - 18));
}
// Calculate expected LP tokens based on Pendle's LpToAssetRate using the normalized amount
uint256 expectedLpOut =
normalizedAmount.mulDiv(PENDLE_LP_PRICE_PRECISION, _getMedianLpToAssetRate(), Math.Rounding.Ceil);
// Calculate minLp amount with max allowed slippage
return _applySlippage(expectedLpOut);
}
/**
* @notice Calculates the minimum acceptable asset tokens received based on provided shares and slippage tolerance.
* @dev Uses median of different timeframe rates to get a more stable price.
* @param _amount The amount of shares.
* @return The minimum acceptable asset tokens received for specified shares amount.
*/
function getMinAllowedTokenOut(
uint256 _amount
) public view returns (uint256) {
// Calculate expected token out at 18 decimal precision
uint256 expectedTokenOut18 =
_amount.mulDiv(_getMedianLpToAssetRate(), PENDLE_LP_PRICE_PRECISION, Math.Rounding.Ceil);
uint256 tokenInDecimals = IERC20Metadata(tokenIn).decimals();
uint256 expectedTokenOutNative = expectedTokenOut18;
if (tokenInDecimals < 18) {
expectedTokenOutNative = expectedTokenOut18 / (10 ** (18 - tokenInDecimals));
} else if (tokenInDecimals > 18) {
expectedTokenOutNative = expectedTokenOut18 * (10 ** (tokenInDecimals - 18));
}
// Calculate min tokenOut amount with max allowed slippage
return _applySlippage(expectedTokenOutNative);
}
// -- Utility Functions --
/**
* @notice Gets the median LP to asset rate from Pendle market across different timeframes.
* @dev Uses 30 minutes, 1 hour, and 2 hour timeframes to calculate a stable median rate.
* @return The median LP to asset rate from the Pendle market.
*/
function _getMedianLpToAssetRate() internal view returns (uint256) {
return _getMedian(
IPMarket(pendleMarket).getLpToAssetRate(30 minutes),
IPMarket(pendleMarket).getLpToAssetRate(1 hours),
IPMarket(pendleMarket).getLpToAssetRate(2 hours)
);
}
/**
* @notice Computes a median value from three numbers.
*/
function _getMedian(uint256 _a, uint256 _b, uint256 _c) internal pure returns (uint256) {
if ((_a >= _b && _a <= _c) || (_a >= _c && _a <= _b)) return _a;
if ((_b >= _a && _b <= _c) || (_b >= _c && _b <= _a)) return _b;
return _c;
}
/**
* @notice Applies slippage tolerance to a given value.
* @dev Reduces the input value by the configured slippage percentage.
* @param _value The value to apply slippage to.
* @return The value after slippage has been applied (reduced).
*/
function _applySlippage(
uint256 _value
) private view returns (uint256) {
return _value - ((_value * allowedSlippagePercentage) / SLIPPAGE_PRECISION);
}
/**
* @notice Sets a new slippage percentage for the strategy.
* @dev Emits a SlippagePercentageSet event.
* @param _newVal The new slippage percentage value (must be <= SLIPPAGE_PRECISION).
*/
function _setSlippagePercentage(
uint256 _newVal
) private {
require(_newVal <= SLIPPAGE_PRECISION, "3002");
emit SlippagePercentageSet({ oldValue: allowedSlippagePercentage, newValue: _newVal });
allowedSlippagePercentage = _newVal;
}
}
"
},
"lib/jigsaw-protocol-v1/lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
"
},
"lib/jigsaw-protocol-v1/lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev An operation with an ERC20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}
"
},
"lib/jigsaw-protocol-v1/lib/openzeppelin-contracts/contracts/utils/math/Math.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Muldiv operation overflow.
*/
error MathOverflowedMulDiv();
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev 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.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
return a / b;
}
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
* @dev 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.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev 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.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
"
},
"lib/jigsaw-protocol-v1/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.20;
/**
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
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).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
/**
* @dev 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
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
/**
* @dev 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
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
/**
* @dev 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
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
/**
* @dev 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
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
/**
* @dev 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
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
/**
* @dev 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
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
/**
* @dev 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
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
/**
* @dev 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
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
/**
* @dev 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
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
/**
* @dev 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
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
/**
* @dev 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
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
/**
* @dev 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
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
/**
* @dev 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
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
/**
* @dev 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
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
/**
* @dev 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
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
/**
* @dev 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
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
/**
* @dev 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
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
/**
* @dev 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
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
/**
* @dev 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
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is Submitted on: 2025-09-24 16:36:09
Comments
Log in to comment.
No comments yet.