Contract Name:
MarketMakerFactory
Contract Source Code:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Address } from "@openzeppelin/contracts/utils/Address.sol";
import { Clones } from "@openzeppelin/contracts/proxy/Clones.sol";
import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import { IMarketFactory, IMarketFactoryV1_2, IMarketFactoryV1_3, IERC165 } from "./IMarketFactory.sol";
import { IMarketMakerV1, IMarketMakerV1_2, MarketMaker, MarketAddressParams, FeeDistributor } from "./MarketMaker.sol";
import { MarketErrors } from "./MarketErrors.sol";
import {
ConditionID, QuestionID, ConditionalTokensErrors, PackedPrices
} from "../conditions/IConditionalTokensV1_2.sol";
import { IConditionOracleV1_2 } from "../conditions/IConditionOracleV1_2.sol";
import { AdminExecutorAccessUpgradeable } from "../AdminExecutorAccess.sol";
import { IParlayConditionalTokens, ParlayLegs } from "../conditions/IParlayConditionalTokens.sol";
import { ArrayMath } from "../Math.sol";
contract MarketMakerFactory is
MarketErrors,
ConditionalTokensErrors,
IMarketFactoryV1_3,
AdminExecutorAccessUpgradeable
{
using ArrayMath for uint256[];
using SafeERC20 for IERC20Metadata;
using Address for address;
using ERC165Checker for address;
address private immutable marketTemplate;
bytes4 private constant ICONDITION_ORACLE_INTERFACE_ID = 0x7d5f49fa;
/// @dev Create a permissioned market factory. Not meant to be upgradeable
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(FeeDistributor feeDistributor, address admin, address executor) {
marketTemplate = address(new MarketMaker(feeDistributor));
initialize(admin, executor);
}
/// @notice Idempotent creation function, that also creates the condition
/// @dev If market has already been created, the event will not be emitted!
function createMarket(uint256 fee, MarketAddressParams calldata addresses, PackedPriceMarketParams memory params)
public
onlyExecutor
returns (IMarketMakerV1)
{
// Leave 1 extra outcome slot for refund outcome
uint256 outcomeSlotCount = PackedPrices.arrayLength(params.packedPrices) + 1;
if (outcomeSlotCount <= 1) revert InvalidPrices();
// Need to prepare condition through oracle, because only it can set
// initial price/halt time directly
if (!addresses.conditionOracle.supportsInterface(ICONDITION_ORACLE_INTERFACE_ID)) {
revert InvalidConditionOracle(addresses.conditionOracle);
}
IConditionOracleV1_2 conditionOracle = IConditionOracleV1_2(addresses.conditionOracle);
// prepareCondition is idempotent, so should not fail if already exists
ConditionID conditionId = conditionOracle.prepareCondition(
addresses.conditionalTokens, params.questionId, outcomeSlotCount, params.packedPrices, params.haltTime
);
return _createMarket(fee, addresses, conditionId, params.haltTime);
}
/// @dev Internal function that assumes condition has already been created
function _createMarket(
uint256 fee,
MarketAddressParams calldata addresses,
ConditionID conditionId,
uint32 haltTime
) private returns (IMarketMakerV1_2) {
// The salt determines the final address of the market clone. One cannot
// deploy two clones with the same salt, because they will clash in
// their address and the deployment would revert.
//
// haltTime and fee are missing from the salt, so noone can keep
// creating markets with different fees and halt times for the same
// questionId.
// The reason they are excluded is because they don't create a
// fundamentally different identity for a market. If you change the
// questionId, it's a market for a different event/bet. If you change
// collateralTokens that's a market with a different payment option.
// conditionalTokens is where settlement is recorded. priceOracle is who is
// the authority to decide the fair prices. haltTime and fee should be
// adjustable on the market itself
bytes32 salt = marketSalt(addresses, conditionId);
MarketMaker.InitParams memory initParams = MarketMaker.InitParams(conditionId, fee);
// Check if clone already exists for this salt. If it does, then we have already created and initialized it
address clone = Clones.predictDeterministicAddress(marketTemplate, salt);
if (clone.isContract()) {
return MarketMaker(clone);
}
address cloneActual = Clones.cloneDeterministic(marketTemplate, salt);
assert(cloneActual == clone); // this always has to be true
MarketMaker market = MarketMaker(clone);
emit MarketMakerCreation(
msg.sender,
market,
addresses.conditionalTokens,
addresses.collateralToken,
initParams.conditionId,
haltTime,
initParams.fee
);
market.initialize(addresses, initParams);
return market;
}
// TODO: remove?
/// @dev Compatibility implementation of old interface without packed prices
function createMarket(uint256 fee, MarketAddressParams calldata addresses, PriceMarketParams memory params)
public
returns (IMarketMakerV1)
{
if (params.haltTime > type(uint32).max) revert InvalidHaltTime();
PackedPriceMarketParams memory newParams = PackedPriceMarketParams(
params.questionId,
PackedPrices.toPackedPrices(params.fairPriceDecimals, PackedPrices.DECIMAL_CONVERSION_FACTOR),
uint32(params.haltTime)
);
return createMarket(fee, addresses, newParams);
}
/// @notice Same as createMarket, but returns the concrete type
/// @dev Need this because of lack of covariant return types: https://github.com/ethereum/solidity/issues/11624
function createMarketConcrete(
uint256 fee,
MarketAddressParams calldata addresses,
PackedPriceMarketParams memory params
) public returns (MarketMaker) {
return MarketMaker(address(createMarket(fee, addresses, params)));
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165, AccessControlUpgradeable)
returns (bool)
{
return interfaceId == type(IMarketFactory).interfaceId || interfaceId == type(IMarketFactoryV1_2).interfaceId
|| interfaceId == type(IMarketFactoryV1_3).interfaceId || super.supportsInterface(interfaceId);
}
// TODO: needs to be idempotent
function createParlayMarket(
uint256 fee,
MarketAddressParams calldata addresses,
uint256 legQuestionIdMask,
ParlayLegs calldata legs
) public returns (IMarketMakerV1_2 marketMaker, QuestionID parlayQuestionId) {
ConditionID parlayConditionId;
// TODO check if interface supported?
(parlayQuestionId, parlayConditionId) = IParlayConditionalTokens(address(addresses.conditionalTokens))
.prepareParlayCondition(addresses.conditionOracle, legQuestionIdMask, legs);
// haltTime isn't explicitly set, since it's derived from the leg halt times. Set it at maximum time in the future.
marketMaker = _createMarket(fee, addresses, parlayConditionId, type(uint32).max);
}
function createParlayMarketConcrete(
uint256 fee,
MarketAddressParams calldata addresses,
uint256 legQuestionIdMask,
ParlayLegs calldata legs
) external returns (MarketMaker, QuestionID) {
(IMarketMakerV1 marketMaker, QuestionID parlayQuestionId) =
createParlayMarket(fee, addresses, legQuestionIdMask, legs);
return (MarketMaker(address(marketMaker)), parlayQuestionId);
}
/// @dev The address of a created market only depends on certain parameters.
/// Use this function to determine the final creation address
function predictMarketAddress(MarketAddressParams calldata addresses, ConditionID conditionId)
public
view
returns (address)
{
bytes32 salt = marketSalt(addresses, conditionId);
return Clones.predictDeterministicAddress(marketTemplate, salt);
}
/// @dev Encapsulates how we derive the salt from the creation parameters
function marketSalt(MarketAddressParams calldata addresses, ConditionID conditionId)
private
pure
returns (bytes32)
{
// priceOracle doesn't matter for salt anymore
return keccak256(
abi.encode(
addresses.conditionalTokens,
addresses.collateralToken,
addresses.parentPool,
addresses.conditionOracle,
conditionId
)
);
}
function initialize(address admin, address executor) private initializer {
__AdminExecutor_init(admin, executor);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
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);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../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;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
/**
* @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, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (proxy/Clones.sol)
pragma solidity ^0.8.0;
/**
* @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
* deploying minimal proxy contracts, also known as "clones".
*
* > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
* > a minimal bytecode implementation that delegates all calls to a known, fixed address.
*
* The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
* (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
* deterministic method.
*
* _Available since v3.4._
*/
library Clones {
/**
* @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
*
* This function uses the create opcode, which should never revert.
*/
function clone(address implementation) internal returns (address instance) {
/// @solidity memory-safe-assembly
assembly {
// Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
// of the `implementation` address with the bytecode before the address.
mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
// Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
instance := create(0, 0x09, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
/**
* @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
*
* This function uses the create2 opcode and a `salt` to deterministically deploy
* the clone. Using the same `implementation` and `salt` multiple time will revert, since
* the clones cannot be deployed twice at the same address.
*/
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
/// @solidity memory-safe-assembly
assembly {
// Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
// of the `implementation` address with the bytecode before the address.
mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
// Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
instance := create2(0, 0x09, 0x37, salt)
}
require(instance != address(0), "ERC1167: create2 failed");
}
/**
* @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
*/
function predictDeterministicAddress(
address implementation,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(add(ptr, 0x38), deployer)
mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
mstore(add(ptr, 0x14), implementation)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
mstore(add(ptr, 0x58), salt)
mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
predicted := keccak256(add(ptr, 0x43), 0x55)
}
}
/**
* @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
*/
function predictDeterministicAddress(address implementation, bytes32 salt)
internal
view
returns (address predicted)
{
return predictDeterministicAddress(implementation, salt, address(this));
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.2) (utils/introspection/ERC165Checker.sol)
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Library used to query support of an interface declared via {IERC165}.
*
* Note that these functions return the actual result of the query: they do not
* `revert` if an interface is not supported. It is up to the caller to decide
* what to do in these cases.
*/
library ERC165Checker {
// As per the EIP-165 spec, no interface should ever match 0xffffffff
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
/**
* @dev Returns true if `account` supports the {IERC165} interface.
*/
function supportsERC165(address account) internal view returns (bool) {
// Any contract that implements ERC165 must explicitly indicate support of
// InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
return
supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) &&
!supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
}
/**
* @dev Returns true if `account` supports the interface defined by
* `interfaceId`. Support for {IERC165} itself is queried automatically.
*
* See {IERC165-supportsInterface}.
*/
function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
// query support of both ERC165 as per the spec and support of _interfaceId
return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
}
/**
* @dev Returns a boolean array where each value corresponds to the
* interfaces passed in and whether they're supported or not. This allows
* you to batch check interfaces for a contract where your expectation
* is that some interfaces may not be supported.
*
* See {IERC165-supportsInterface}.
*
* _Available since v3.4._
*/
function getSupportedInterfaces(address account, bytes4[] memory interfaceIds)
internal
view
returns (bool[] memory)
{
// an array of booleans corresponding to interfaceIds and whether they're supported or not
bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);
// query support of ERC165 itself
if (supportsERC165(account)) {
// query support of each interface in interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
}
}
return interfaceIdsSupported;
}
/**
* @dev Returns true if `account` supports all the interfaces defined in
* `interfaceIds`. Support for {IERC165} itself is queried automatically.
*
* Batch-querying can lead to gas savings by skipping repeated checks for
* {IERC165} support.
*
* See {IERC165-supportsInterface}.
*/
function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
// query support of ERC165 itself
if (!supportsERC165(account)) {
return false;
}
// query support of each interface in interfaceIds
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
return false;
}
}
// all interfaces supported
return true;
}
/**
* @notice Query if a contract implements an interface, does not check ERC165 support
* @param account The address of the contract to query for support of an interface
* @param interfaceId The interface identifier, as specified in ERC-165
* @return true if the contract at account indicates support of the interface with
* identifier interfaceId, false otherwise
* @dev Assumes that account contains a contract that supports ERC165, otherwise
* the behavior of this method is undefined. This precondition can be checked
* with {supportsERC165}.
*
* Some precompiled contracts will falsely indicate support for a given interface, so caution
* should be exercised when using this function.
*
* Interface identification is specified in ERC-165.
*/
function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
// prepare call
bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);
// perform static call
bool success;
uint256 returnSize;
uint256 returnValue;
assembly {
success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
returnSize := returndatasize()
returnValue := mload(0x00)
}
return success && returnSize >= 0x20 && returnValue > 0;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `_msgSender()` is missing `role`.
* Overriding this function changes the behavior of the {onlyRole} modifier.
*
* Format of the revert message is described in {_checkRole}.
*
* _Available since v4.6._
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
StringsUpgradeable.toHexString(account),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32)
)
)
);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleGranted} event.
*/
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleRevoked} event.
*/
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been revoked `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* May emit a {RoleGranted} event.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*
* NOTE: This function is deprecated in favor of {_grantRole}.
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Grants `role` to `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
/**
* @dev Revokes `role` from `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import { IMarketMakerV1 } from "./IMarketMaker.sol";
import { IMarketMakerV1_2 } from "./IMarketMakerV1_2.sol";
import { MarketAddressParams } from "./MarketAddressParams.sol";
import { IConditionalTokens, ConditionID, QuestionID } from "../conditions/IConditionalTokens.sol";
import { ParlayLegs } from "../conditions/IParlayConditionalTokens.sol";
/// @title Events for a market factory
/// @dev Use these events for blockchain indexing
interface IMarketFactoryEvents {
event MarketMakerCreation(
address indexed creator,
IMarketMakerV1 marketMaker,
IConditionalTokens indexed conditionalTokens,
IERC20 indexed collateralToken,
ConditionID conditionId,
uint256 haltTime,
uint256 fee
);
}
interface IMarketFactory is IMarketFactoryEvents, IERC165 {
/// @dev Parameters unique to a single Market creation
struct PriceMarketParams {
QuestionID questionId;
uint256[] fairPriceDecimals;
uint128 minPriceDecimal;
uint256 haltTime;
}
function createMarket(uint256 fee, MarketAddressParams calldata addresses, PriceMarketParams memory params)
external
returns (IMarketMakerV1);
}
interface IMarketFactoryV1_2 is IMarketFactory {
/// @dev Parameters unique to a single Market creation, with packed prices
struct PackedPriceMarketParams {
QuestionID questionId;
bytes packedPrices;
uint32 haltTime;
}
function createMarket(uint256 fee, MarketAddressParams calldata addresses, PackedPriceMarketParams memory params)
external
returns (IMarketMakerV1);
}
interface IMarketFactoryV1_3 is IMarketFactoryV1_2 {
/// @dev create a parlay market out of other conditions. The
/// conditionalTokens address is assumed to be an instance of
/// ParlayConditionalTokens
function createParlayMarket(
uint256 fee,
MarketAddressParams calldata addresses,
uint256 legQuestionIdMask,
ParlayLegs calldata legs
) external returns (IMarketMakerV1_2, QuestionID);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { IERC165Upgradeable } from "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import { IERC1155ReceiverUpgradeable } from
"@openzeppelin/contracts-upgradeable/token/ERC1155/IERC1155ReceiverUpgradeable.sol";
import { ERC1155ReceiverUpgradeable } from
"@openzeppelin/contracts-upgradeable/token/ERC1155/utils/ERC1155ReceiverUpgradeable.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import {
IConditionalTokensV1_2,
ConditionID,
ConditionalTokensErrors,
CTHelpers
} from "../conditions/IConditionalTokensV1_2.sol";
import { FundingPool, IFundingPoolV1_1, IFundingPoolV1 } from "../funding/FundingPool.sol";
import { ChildFundingPool, IChildFundingPoolV1, IParentFundingPoolV1 } from "../funding/ChildFundingPool.sol";
import { FeeDistributor, FeeProfileID } from "../funding/FeeDistributor.sol";
import { IMarketMakerV1 } from "./IMarketMaker.sol";
import { IMarketMakerV1_2 } from "./IMarketMakerV1_2.sol";
import { AmmMath } from "./AmmMath.sol";
import { MarketAddressParams } from "./MarketAddressParams.sol";
import { FundingMath } from "../funding/FundingMath.sol";
import { ClampedMath, ArrayMath } from "../Math.sol";
/// @title A contract for providing a market for users to bet on
/// @notice A Market for buying, selling bets as a bettor, and adding/removing
/// liquidity as a liquidity provider. Any fees acrued due to trading activity
/// is then given to the liquidity providers.
/// @dev This is using upgradeable contracts because it will be called through a
/// proxy. We will not actually be upgrading the proxy, but using proxies for
/// cloning. As such, storage compatibilities between upgrades don't matter for
/// the Market.
contract MarketMaker is
Initializable,
ERC1155ReceiverUpgradeable,
IMarketMakerV1_2,
ChildFundingPool,
FundingPool,
ConditionalTokensErrors
{
using ArrayMath for uint256[];
using Math for uint256;
using ClampedMath for uint256;
using SafeERC20 for IERC20Metadata;
struct InitParams {
ConditionID conditionId;
uint256 fee;
}
uint256 private constant PRECISION_DECIMALS = AmmMath.PRECISION_DECIMALS;
uint256 public constant ONE_DECIMAL = AmmMath.ONE_DECIMAL;
/// @dev Explicitly ok with immutable state variable as that is set in stone
/// in the code deployed, rather than in the storage of every instance of
/// the proxy. We are not doing upgrades, so should be ok.
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable
FeeDistributor private immutable FEE_DISTRIBUTOR;
IConditionalTokensV1_2 public conditionalTokens;
ConditionID public conditionId;
// All decimal values are < 1e18, which can fit in uint64, so can be packed more tightly
uint64 public feeDecimal;
uint64 public minInvestment;
/// @dev Keep track of fees retained by each fee profile. Note that since
/// not all profile ids may be approved, any fees for unapproved fee
/// profiles just end up given back to the parent pool
mapping(FeeProfileID => uint256) private feesByProfile;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(FeeDistributor feeDistributor) {
// immutable fields get baked into the code, and not storage, so need to
// pass these in constructor, not initializer.
FEE_DISTRIBUTOR = feeDistributor;
_disableInitializers();
}
function initialize(MarketAddressParams calldata addresses, InitParams calldata params) public initializer {
// Cannot create a market without a parent, because individual funders are forbidden
if (addresses.parentPool == address(0x0)) revert NotAParentPool(addresses.parentPool);
__ChildFundingPool_init(addresses.parentPool);
__FundingPool_init(addresses.collateralToken);
__ERC1155Receiver_init();
conditionalTokens = addresses.conditionalTokens;
conditionId = params.conditionId;
if (isHalted()) revert MarketHalted();
// Check collateral decimals are not too big
uint256 collateralDecimals = collateralToken.decimals();
uint256 oneCollateral = 10 ** collateralDecimals;
if (oneCollateral >= type(uint64).max) revert ExcessiveCollateralDecimals();
// Check if fee makes sense. It has to be < 1.0
if (params.fee >= oneCollateral) revert InvalidFee();
// Calculate numeric values on the stack and write them out at once after
uint256 minInvestment_;
if (params.fee > 0) {
// Set the minInvestment such that fee will always be non-zero
minInvestment_ = oneCollateral.ceilDiv(params.fee);
assert(minInvestment_ * params.fee > 0);
} else {
// if no fee, investment needs to be non-zero
minInvestment_ = 1;
}
// Assert that precision decimals are not excessive.
// This is not a requirement, but an assertion because it's a code constant
assert(10 ** PRECISION_DECIMALS <= type(uint64).max);
// Fee is given in terms of token decimals, but in calculations we use 1 ether precision
// We need to normalize the fee to our calculation precision.
// Given the above checks, the result should fit within uint64, since it is at most 10 ** PRECISION_DECIMALS
uint256 feeDecimal_;
if (collateralDecimals < PRECISION_DECIMALS) {
feeDecimal_ = params.fee * (10 ** (PRECISION_DECIMALS - collateralDecimals));
} else if (collateralDecimals > PRECISION_DECIMALS) {
feeDecimal_ = params.fee / (10 ** (collateralDecimals - PRECISION_DECIMALS));
} else {
feeDecimal_ = params.fee;
}
// Write out adjacent values all at once to take advantage of packing and reducing SSTORE calls
feeDecimal = uint64(feeDecimal_);
minInvestment = uint64(minInvestment_);
{
// Ensure they are all stored in the same slot
uint256 feeSlot;
uint256 minInvestmentSlot;
assembly {
feeSlot := feeDecimal.slot
minInvestmentSlot := minInvestment.slot
}
assert(feeSlot == minInvestmentSlot);
}
}
/// @inheritdoc IFundingPoolV1
// solhint-disable-next-line ordering
function addFunding(uint256 collateralAdded) external returns (uint256 sharesMinted) {
return addFundingFor(_msgSender(), collateralAdded);
}
/// @notice Removes market funds of someone if the condition is resolved.
/// All conditional tokens that were part of the position are redeemed and
/// only collateral is returned
/// @param ownerAndReceiver Address where the collateral will be deposited,
/// and who owns the LP tokens
/// @param sharesToBurn portion of LP pool to remove
function removeCollateralFundingOf(address ownerAndReceiver, uint256 sharesToBurn)
public
returns (uint256[] memory sendAmounts, uint256 collateralRemoved)
{
if (!conditionalTokens.isResolved(conditionId)) revert MarketUndecided();
// Fees are distributed first, unless there is a refund, in which case
// all the fee collateral will get transferred back to the parent by the
// code below
(FeeProfileID[] memory profileIds, uint256[] memory profileAmounts, uint256 totalFeeDistributionAmount) =
_calcDistributeFees();
// Make any collateral that will not go to the fee distributor part of reserves
_unlockFees(collectedFees - totalFeeDistributionAmount);
// Remove from reserves
(collateralRemoved, sendAmounts) = _calcRemoveFunding(sharesToBurn);
_burnSharesOf(ownerAndReceiver, sharesToBurn);
uint256 outcomeSlotCount = sendAmounts.length;
assert(outcomeSlotCount > 0);
uint256[] memory indices = new uint256[](outcomeSlotCount);
for (uint256 i = 0; i < outcomeSlotCount; i++) {
indices[i] = i;
}
if (collateralRemoved > 0) {
collateralToken.safeTransfer(ownerAndReceiver, collateralRemoved);
}
collateralRemoved +=
conditionalTokens.redeemPositionsFor(ownerAndReceiver, collateralToken, conditionId, indices, sendAmounts);
_distributeFees(profileIds, profileAmounts, totalFeeDistributionAmount);
address parent = getParentPool();
if (ownerAndReceiver == parent) {
IParentFundingPoolV1(parent).fundingReturned(collateralRemoved, sharesToBurn);
}
uint256[] memory noTokens = new uint256[](0);
emit FundingRemoved(ownerAndReceiver, collateralRemoved, noTokens, sharesToBurn);
}
/// @notice Removes all the collateral for funders. Anyone can call
/// this function after the condition is resolved.
/// @return totalSharesBurnt Total amount of shares that were burnt.
/// @return totalCollateralRemoved Total amount of collateral removed.
function removeAllCollateralFunding(address[] calldata funders)
external
returns (uint256 totalSharesBurnt, uint256 totalCollateralRemoved)
{
for (uint256 i = 0; i < funders.length; i++) {
address funder = funders[i];
uint256 sharesToBurn_ = balanceOf(funder);
if (sharesToBurn_ == 0) continue;
(, uint256 collateralRemoved_) = removeCollateralFundingOf(funder, sharesToBurn_);
totalCollateralRemoved += collateralRemoved_;
totalSharesBurnt += sharesToBurn_;
}
}
/// @notice Removes funds from the market by burning the shares and sending
/// to the transaction sender his portion of conditional tokens and collateral.
/// @param sharesToBurn portion of LP pool to remove
/// @return collateral how much collateral was returned
/// @return sendAmounts how much of each conditional token was returned
function removeFunding(uint256 sharesToBurn) external returns (uint256 collateral, uint256[] memory sendAmounts) {
address funder = _msgSender();
return _removeFunding(funder, sharesToBurn);
}
function _removeFunding(address funder, uint256 sharesToBurn)
private
returns (uint256 collateral, uint256[] memory sendAmounts)
{
(collateral, sendAmounts) = _calcRemoveFunding(sharesToBurn);
_burnSharesOf(funder, sharesToBurn);
collateralToken.safeTransfer(funder, collateral);
uint256 outcomeSlotCount = sendAmounts.length;
conditionalTokens.safeBatchTransferFrom(
address(this),
funder,
CTHelpers.getPositionIds(collateralToken, conditionId, outcomeSlotCount),
sendAmounts,
""
);
address parent = getParentPool();
if (funder == parent) {
IParentFundingPoolV1(parent).fundingReturned(collateral, sharesToBurn);
}
emit FundingRemoved(funder, collateral, sendAmounts, sharesToBurn);
}
function _calcRemoveFunding(uint256 sharesToBurn)
private
view
returns (uint256 collateral, uint256[] memory returnAmounts)
{
uint256 totalShares = totalSupply();
collateral = FundingMath.calcReturnAmount(sharesToBurn, totalShares, reserves());
returnAmounts = FundingMath.calcReturnAmounts(sharesToBurn, totalShares, getPoolBalances());
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal override {
// When address other than parent gets shares, immediately eject them to
// maintain invariant that all funding is by parent
if (from == getParentPool() && to != address(0x0)) {
_removeFunding(to, amount);
}
}
/// @notice Buys an amount of a conditional token position.
/// @param investmentAmount Amount of collateral to exchange for the collateral tokens.
/// @param outcomeIndex Position index of the condition to buy.
/// @param minOutcomeTokensToBuy Minimal amount of conditional token expected to be received.
function buy(uint256 investmentAmount, uint256 outcomeIndex, uint256 minOutcomeTokensToBuy)
external
returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices)
{
return buyFor(_msgSender(), investmentAmount, outcomeIndex, minOutcomeTokensToBuy, 0, FeeProfileID.wrap(0x0));
}
/// @notice Sells an amount of conditional tokens and get collateral as a
/// return. Currently not supported and will be implemented soon.
function sell(uint256 returnAmount, uint256, /* outcomeIndex */ uint256 /* maxOutcomeTokensToSell */ )
external
view
returns (uint256)
{
if (isHalted()) revert MarketHalted();
if (returnAmount == 0) revert InvalidReturnAmount();
revert OperationNotSupported();
}
/// @notice Price updates have moved to Conditional Tokens.
function updateFairPrices(uint256[] calldata /* fairPriceDecimals */ ) external pure {
revert OperationNotSupported();
}
/// @notice Deprecated because refund outcome always has price of 0
function updateMinPrice(uint128 /* _minPriceDecimal */ ) external pure {
revert OperationNotSupported();
}
/// @notice Return the current fair prices used by the market, normalized to ONE_DECIMAL
function getFairPrices() external view returns (uint256[] memory) {
return conditionalTokens.getFairPrices(conditionId);
}
/// @notice Return the current prices that include the spread due to the AMM
/// algorithm. The prices will sum to more than ONE_DECIMAL, because there
/// is a spread incorporated into the price
function getSpontaneousPrices() external view returns (uint256[] memory) {
(AmmMath.TargetContext memory targetContext, uint256[] memory fairPriceDecimals) = getTargetBalance();
return AmmMath.calcSpontaneousPricesV3(
targetContext.target, targetContext.globalReserves, targetContext.balances, fairPriceDecimals
);
}
function getPoolValue() public view returns (uint256) {
(uint256[] memory poolBalances, uint256[] memory fairPriceDecimals) =
conditionalTokens.getPositionInfo(address(this), collateralToken, conditionId);
return AmmMath.calcPoolValue(poolBalances, fairPriceDecimals, reserves());
}
/// @inheritdoc IFundingPoolV1
function addFundingFor(address receiver, uint256 collateralAdded) public returns (uint256 sharesMinted) {
if (isHalted()) revert MarketHalted();
if (receiver != getParentPool()) revert CanOnlyBeFundedByParent();
sharesMinted = _mintSharesFor(receiver, collateralAdded, getPoolValue());
// Don't split through all conditions, keep collateral as collateral, until we actually need it
}
/// @notice Buys conditional tokens for a particular account.
/// @dev This function is to buy conditional tokens by a third party on behalf of a particular account.
/// @param outcomeIndex Position index of the condition to buy.
/// @param minOutcomeTokensToBuy Minimal amount of conditional token expected to be received.
/// @return outcomeTokensBought quantity of conditional tokens that were bought
/// @return feeAmount how much collateral went to fees
function buyFor(address receiver, uint256 investmentAmount, uint256 outcomeIndex, uint256 minOutcomeTokensToBuy)
external
returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices)
{
return buyFor(receiver, investmentAmount, outcomeIndex, minOutcomeTokensToBuy, 0, FeeProfileID.wrap(0x0));
}
function buyFor(
address receiver,
uint256 investmentAmount,
uint256 outcomeIndex,
uint256 minOutcomeTokensToBuy,
uint256 extraFeeDecimal,
FeeProfileID feeProfileId
) public returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices) {
if (isHalted()) revert MarketHalted();
if (investmentAmount < minInvestment) revert InvalidInvestmentAmount();
uint256 tokensToMint;
uint256 refundIndex;
AmmMath.ParentOperations memory parentOps;
{
(AmmMath.TargetContext memory targetContext, uint256[] memory fairPriceDecimals) = getTargetBalance();
refundIndex = AmmMath.getRefundIndex(targetContext);
(outcomeTokensBought, tokensToMint, feeAmount, spontaneousPrices, parentOps) =
_calcBuyAmount(investmentAmount, outcomeIndex, extraFeeDecimal, targetContext, fairPriceDecimals);
}
if (outcomeTokensBought < minOutcomeTokensToBuy) revert MinimumBuyAmountNotReached();
// Request from parent first, before receiving any collateral from the
// buyer, otherwise the extra collateral from the buyer skews the pool
// value. This skew is wrong because that extra collateral will be used
// to mint conditional tokens and be given away.
_applyParentRequest(parentOps);
collateralToken.safeTransferFrom(_msgSender(), address(this), investmentAmount);
// Should set aside the fee collateral. In case of a refund outcome, all of the fee
// goes back to LP because LP provided the collateral for the refund in
// the first place
_retainFees(feeAmount, feeProfileId);
if (tokensToMint > 0) {
// We need to mint some tokens
splitPositionThroughAllConditions(tokensToMint);
}
conditionalTokens.safeTransferFrom(address(this), receiver, positionId(outcomeIndex), outcomeTokensBought, "");
// Last index outcome is the refund outcome. Give back the same amount of tokens as collateral invested, including fees
conditionalTokens.safeTransferFrom(address(this), receiver, positionId(refundIndex), investmentAmount, "");
// Return collateral back to parent once everything is settled with the buyer
_applyParentReturn(parentOps);
emit MarketBuy(receiver, investmentAmount, feeAmount, outcomeIndex, outcomeTokensBought);
emit MarketSpontaneousPrices(spontaneousPrices);
}
/// @inheritdoc IERC1155ReceiverUpgradeable
function onERC1155Received(
address operator,
address, /* from */
uint256, /* id */
uint256, /* value */
bytes memory /* data */
) public view override returns (bytes4) {
// receives conditional tokens for the liquidity pool,
// or transfer from a user for purpose of selling that token
if (operator == address(this) && _msgSender() == address(conditionalTokens)) {
return this.onERC1155Received.selector;
}
return 0x0;
}
/// @inheritdoc IERC1155ReceiverUpgradeable
function onERC1155BatchReceived(
address operator,
address from,
uint256[] memory, /* ids */
uint256[] memory, /* values */
bytes memory /* data */
) public view override returns (bytes4) {
// receives conditional tokens for the liquidity pool from splitPositions
if (operator == address(this) && from == address(0) && _msgSender() == address(conditionalTokens)) {
return this.onERC1155BatchReceived.selector;
}
return 0x0;
}
/// @dev Convenience view function to calculate a positionId (ERC1155 id) for an outcome
function positionId(uint256 outcomeIndex) public view returns (uint256) {
return CTHelpers.getPositionId(collateralToken, CTHelpers.getCollectionId(conditionId, outcomeIndex));
}
/// @notice Calculate the amount of conditional token to be bought with a certain amount of collateral.
/// @param investmentAmount Amount of collateral token invested.
/// @param indexOut Position index of the condition.
/// @return outcomeTokensBought how many outcome tokens would the user receive from the transaction
function calcBuyAmount(uint256 investmentAmount, uint256 indexOut)
external
view
returns (uint256, uint256, uint256[] memory)
{
return calcBuyAmount(investmentAmount, indexOut, 0);
}
function calcBuyAmount(uint256 investmentAmount, uint256 indexOut, uint256 extraFeeDecimal)
public
view
returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices)
{
(AmmMath.TargetContext memory targetContext, uint256[] memory fairPriceDecimals) = getTargetBalance();
(outcomeTokensBought,, feeAmount, spontaneousPrices,) =
_calcBuyAmount(investmentAmount, indexOut, extraFeeDecimal, targetContext, fairPriceDecimals);
}
/// @dev Calculate the amount of a conditional token to be bought with a
/// certain amount of collateral. This private function also provides a lot
/// of other information on how to deal with an external parent pool.
///
/// Some invariants:
/// - No collateral stays in the market - reserves should be 0. The minimal
/// amount of collateral is requested from the parent in order to mint
/// tokens. Any excess after all operations is given back to the parent
/// - At the end of a buy operation at least one of the token balances is 0,
/// otherwise some amount would be mergeable. The market remains without
/// collateral reserves, and with some tokens besides the output token. If
/// a subsequent buy takes some tokens that are readily available, that
/// allows us to return the investment collateral of the buyer back to the
/// parent pool, since we don't need it to mint any tokens.
/// - This means the parent pool's effective funding is ALWAYS in terms of
/// tokens in the market, because any excess collateral is always returned
/// back to the parent
/// - The AMM algorithm aims to keep the pool value constant, and all the
/// balances to be at a target. This target is the cost basis of all
/// funding. The idea is all revenue comes from a flat fee on trades, and
/// the funding pool itself tries to keep a steady value.
/// - Sometimes a bet results in a "push" requiring a full refund. This
/// necessitates setting aside an outcome for a full refund. Tokens of this
/// extra outcome are worth zero during normal trading, and are given out
/// 1:1 for every collateral the user puts in. This has to be taken into
/// account when calculating how much to request from the parent, since we
/// also need to mint enough tokens to fulfill the refund obligation
/// @param investment Amount of collateral token used to buy tokens
/// @param indexOut Position index of the condition.
/// @param extraFeeDecimal extra fees as a decimal to add on top of existing fees
/// @param targetContext the current state of the pool - target, balances, available liquidity
/// @param fairPriceDecimals current fair prices for all priced outcomes
/// @return outcomeTokensBought how many outcome tokens would the user receive from the transaction
/// @return tokensToMint the minimal number of tokens to mint in order to satisfy the order
/// @return fees how much collateral is taken as fees
/// @return spontaneousPrices pries of tokens after the buy
/// @return parentOps operations to perform with parent funding
function _calcBuyAmount(
uint256 investment,
uint256 indexOut,
uint256 extraFeeDecimal,
AmmMath.TargetContext memory targetContext,
uint256[] memory fairPriceDecimals
)
private
view
returns (
uint256 outcomeTokensBought,
uint256 tokensToMint,
uint256 fees,
uint256[] memory spontaneousPrices,
AmmMath.ParentOperations memory parentOps
)
{
fees = (investment * (feeDecimal + extraFeeDecimal)) / ONE_DECIMAL;
if (fees >= investment) revert FeesConsumeInvestment();
uint256 investmentMinusFees = investment - fees;
(uint256 tokensExchanged, uint256 newPoolValue) = AmmMath.calcBuyAmountV3(
investmentMinusFees,
indexOut,
targetContext.target,
targetContext.globalReserves,
targetContext.balances,
fairPriceDecimals
);
AmmMath.BuyContext memory buyContext =
AmmMath.BuyContext(investmentMinusFees, tokensExchanged, newPoolValue, investment);
address parent = getParentPool();
uint256 parentShares = balanceOf(parent);
assert(parentShares == totalSupply()); // All shares should be owned by parent
(outcomeTokensBought, tokensToMint, parentOps) =
AmmMath.calcMarketPoolChanges(indexOut, parentShares, targetContext, buyContext);
spontaneousPrices = AmmMath.calcSpontaneousPricesV3(
targetContext.target, targetContext.globalReserves, targetContext.balances, fairPriceDecimals
);
}
/// @notice Calculates the amount of conditional tokens that should be sold to receive a particular amount of
/// collateral. Currently not supported but will be implemented soon
function calcSellAmount(uint256, /* returnAmount */ uint256 /* outcomeIndex */ ) public pure returns (uint256) {
revert OperationNotSupported();
}
/// ERC165
/// @dev This should check all incremental interfaces. Reasoning:
/// - Market shows support for all revisions of the interface up to latest.
/// - BatchBet checks the minimal version that supports the function it needs.
/// - Any other contract also only checks the minimal version that supports the function it needs.
/// - When a new interface is released, there is no need to release new versions of "user" contracts like
/// BatchBet, because they use the minimal interface and new releases of markets will be backwards compatible.
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(IERC165Upgradeable, ERC1155ReceiverUpgradeable)
returns (bool)
{
return interfaceId == type(IMarketMakerV1).interfaceId || interfaceId == type(IChildFundingPoolV1).interfaceId
|| interfaceId == type(IFundingPoolV1).interfaceId || interfaceId == type(IFundingPoolV1_1).interfaceId
|| interfaceId == type(IMarketMakerV1_2).interfaceId
|| ERC1155ReceiverUpgradeable.supportsInterface(interfaceId);
}
/// @notice Returns true/false if the market is currently halted or not, respectively.
/// @dev It would be more convenient to use block number since the timestamp is modifiable by miners
function isHalted() public view returns (bool) {
return conditionalTokens.isHalted(conditionId);
}
/// @notice Computes the pool balance in conditional token for each market position.
/// @return poolBalances The pool balance in conditional tokens for each position.
function getPoolBalances() public view returns (uint256[] memory) {
return conditionalTokens.balanceOfCondition(address(this), collateralToken, conditionId);
}
/// @dev It would be maybe convenient to remove this function since it is used only once in the code and adds extra
/// complexity. If it names clarifies better what splitPosition those it could be just changed in the
/// ConditionalContract
function splitPositionThroughAllConditions(uint256 amount) private {
collateralToken.safeApprove(address(conditionalTokens), amount);
conditionalTokens.splitPosition(collateralToken, conditionId, amount);
}
/// @dev Requests funds from parent if needed
function _applyParentRequest(AmmMath.ParentOperations memory parentOps) private {
address parent = getParentPool();
if (parentOps.collateralToRequestFromParent > 0) {
assert(parentOps.collateralToReturnToParent == 0);
assert(parentOps.sharesToBurnOfParent == 0);
// We need more collateral than available in reserves, so ask the parent
assert(parent != address(0x0));
(uint256 fundingGiven,) =
IParentFundingPoolV1(parent).requestFunding(parentOps.collateralToRequestFromParent);
if (fundingGiven < parentOps.collateralToRequestFromParent) revert InvestmentDrainsPool();
}
}
/// @dev Returns funds back to parent if available
function _applyParentReturn(AmmMath.ParentOperations memory parentOps) private {
address parent = getParentPool();
if (parentOps.sharesToBurnOfParent > 0 || parentOps.collateralToReturnToParent > 0) {
assert(parentOps.collateralToRequestFromParent == 0);
// We have extra collateral that should be returned back to the parent
assert(parent != address(0x0));
if (parentOps.sharesToBurnOfParent > 0) {
_burnSharesOf(parent, parentOps.sharesToBurnOfParent);
}
if (parentOps.collateralToReturnToParent > 0) {
collateralToken.safeTransfer(parent, parentOps.collateralToReturnToParent);
}
IParentFundingPoolV1(parent).fundingReturned(
parentOps.collateralToReturnToParent, parentOps.sharesToBurnOfParent
);
uint256[] memory noTokens = new uint256[](0);
emit FundingRemoved(parent, parentOps.collateralToReturnToParent, noTokens, parentOps.sharesToBurnOfParent);
}
}
/// @dev calculates how the fees should be distributed. Calculation is split from action to avoid re-entrancy attacks
function _calcDistributeFees()
private
view
returns (FeeProfileID[] memory profileIds, uint256[] memory profileAmounts, uint256 totalAmount)
{
uint256 collectedFees_ = collectedFees;
if (collectedFees_ == 0) return (profileIds, profileAmounts, totalAmount);
// If there is a refund, all fees go back to parent since it funded the
// refunds in the first place. No distribution to others takes place
(uint256[] memory numerators,) = conditionalTokens.getPayouts(conditionId);
uint256 refundIndex = AmmMath.getRefundIndex(numerators);
if (numerators[refundIndex] > 0) return (profileIds, profileAmounts, totalAmount);
// Send to fee distributor
profileIds = FEE_DISTRIBUTOR.approvedProfiles();
profileAmounts = new uint256[](profileIds.length);
totalAmount = 0;
for (uint256 i = 0; i < profileIds.length; i++) {
FeeProfileID profileId = profileIds[i];
uint256 profileFees = feesByProfile[profileId];
if (profileFees == 0) continue;
profileAmounts[i] = profileFees;
totalAmount += profileFees;
}
}
function _distributeFees(FeeProfileID[] memory profileIds, uint256[] memory profileAmounts, uint256 totalAmount)
private
{
if (totalAmount == 0) return;
// Make fees part of reserves
_unlockFees(totalAmount);
collateralToken.approve(address(FEE_DISTRIBUTOR), totalAmount);
FEE_DISTRIBUTOR.transferToProfiles(collateralToken, profileIds, profileAmounts);
}
function _retainFees(uint256 feeAmount, FeeProfileID feeProfileId) private {
_retainFees(feeAmount);
if (FeeProfileID.unwrap(feeProfileId) != 0x0) {
feesByProfile[feeProfileId] += feeAmount;
}
}
/// @dev Gets the actual target balance available, that includes any
/// potential funding from the parent pool.
/// @return targetContext relevant quantities needed to work with the liquidity pool
function getTargetBalance()
public
view
returns (AmmMath.TargetContext memory targetContext, uint256[] memory fairPriceDecimals)
{
// The logic is such that any excess collateral is always returned to the parent
// We don't use reserves() here as that may be altered by donations to the market
uint256[] memory balances;
(balances, fairPriceDecimals) = conditionalTokens.getPositionInfo(address(this), collateralToken, conditionId);
// Ensure last price is for refund outcome and price is 0
assert(balances.length == fairPriceDecimals.length + 1);
targetContext =
AmmMath.TargetContext({ target: getTotalFunderCostBasis(), globalReserves: 0, balances: balances });
// check how much funding we can actually request from parent
address parent = getParentPool();
if (parent != address(0x0)) {
(uint256 availableFromParent, uint256 availableTarget) =
IParentFundingPoolV1(parent).getAvailableFunding(address(this));
targetContext.target += availableTarget;
targetContext.globalReserves += availableFromParent;
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { AmmErrors } from "./AmmErrors.sol";
import { FundingErrors } from "../funding/FundingErrors.sol";
interface MarketErrors is AmmErrors, FundingErrors {
error MarketHalted();
error MarketUndecided();
// Buy
error InvalidInvestmentAmount();
error MinimumBuyAmountNotReached();
error FeesConsumeInvestment();
// Sell
error InvalidReturnAmount();
error MaximumSellAmountExceeded();
error InvestmentDrainsPool();
error OperationNotSupported();
error CanOnlyBeFundedByParent();
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IConditionalTokensEvents, IConditionalTokens, IERC20, ConditionalTokensErrors } from "./IConditionalTokens.sol";
import { PackedPrices } from "../PackedPrices.sol";
import { ConditionID, QuestionID, CTHelpers } from "./CTHelpers.sol";
interface IConditionalTokensEventsV1_2 is IConditionalTokensEvents {
/// @dev Event emitted only when a condition is prepared to save on gas costs
/// @param conditionId which condition had its price set
/// @param packedPrices the encoded prices in a byte array
event ConditionPricesUpdated(ConditionID indexed conditionId, bytes packedPrices);
/// @dev Halt time for a condition has been updated
event HaltTimeUpdated(ConditionID indexed conditionId, uint32 haltTime);
}
interface IConditionalTokensV1_2 is IConditionalTokens, IConditionalTokensEventsV1_2 {
struct PriceUpdate {
ConditionID conditionId;
bytes packedPrices;
}
struct HaltUpdate {
ConditionID conditionId;
/// @dev haltTime as seconds since epoch, same as block.timestamp
/// unsigned 32bit epoch timestamp in seconds should be suitable until year 2106
uint32 haltTime;
}
function prepareConditionByOracle(
QuestionID questionId,
uint256 outcomeSlotCount,
bytes calldata packedPrices,
uint32 haltTime_
) external returns (ConditionID);
function updateFairPrices(ConditionID conditionId, bytes calldata packedPrices) external;
function batchUpdateFairPrices(PriceUpdate[] calldata priceUpdates) external;
function getFairPrices(ConditionID conditionId) external view returns (uint256[] memory fairPriceDecimals);
function updateHaltTime(ConditionID conditionId, uint32 haltTime) external;
function batchUpdateHaltTimes(HaltUpdate[] calldata haltUpdates) external;
/// @dev Returns the halt time of a condition. Will be 0 if no price oracle
/// is configured (if old prepareCondition was called).
function haltTime(ConditionID conditionId) external view returns (uint32);
/// @dev Returns if the condition is halted or already resolved. Halting
/// only effects price updates. If no price oracle was configured for a
/// condition, this will always return true. This is ok since it does not
/// affect any other aspect.
function isHalted(ConditionID conditionId) external view returns (bool);
/// @dev combines together balanceOfCondition and getFairPrices into one call to minimize gas usage
function getPositionInfo(address account, IERC20 collateralToken, ConditionID conditionId)
external
view
returns (uint256[] memory balances, uint256[] memory fairPriceDecimals);
/// @dev Get the current payouts for a condition.
function getPayouts(ConditionID conditionId)
external
view
returns (uint256[] memory numerators, uint256 denominator);
}
interface ILegConditionalTokens {
/// @dev given conditions and indices within those conditions, gives the fair price for the parlay
function getParlayFairPrices(ConditionID[] calldata conditionIds, uint256[] calldata indices)
external
view
returns (uint256[] memory fairPriceDecimals);
/// @dev given conditions and indices within those conditions, gives the payout for the parlay
function getParlayPayouts(ConditionID[] calldata conditionIds, uint256[] calldata indices)
external
view
returns (uint256[] memory numerators, uint256 denominator);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IConditionalTokens, IConditionalTokensV1_2, QuestionID, ConditionID } from "./IConditionalTokensV1_2.sol";
interface IConditionOracleV1_2 {
function batchReportPayouts(
IConditionalTokens conditionalTokens,
QuestionID[] calldata questionIDs,
uint256[] calldata payouts,
uint256[] calldata outcomeSlotCounts
) external;
function batchUpdateHaltTimes(
IConditionalTokensV1_2 conditionalTokens,
IConditionalTokensV1_2.HaltUpdate[] calldata haltUpdates
) external;
function batchUpdatePackedPrices(
IConditionalTokensV1_2 condTokens,
IConditionalTokensV1_2.PriceUpdate[] calldata priceUpdates
) external;
function prepareCondition(
IConditionalTokensV1_2 condTokens,
QuestionID questionId,
uint256 outcomeSlotCount,
bytes calldata packedPrices,
uint32 haltTime
) external returns (ConditionID);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { AccessControlUpgradeable } from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import { PausableUpgradeable } from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
/// @dev Simple Access Control, that has an admin role that administers an
/// executor role. The intent is to have a multi-sig or other mechanism to be
/// the admin, and be able to grant/revoke accounts as executors.
abstract contract AdminExecutorAccessUpgradeable is AccessControlUpgradeable, PausableUpgradeable {
bytes32 public constant EXECUTOR_ROLE = keccak256("EXECUTOR_ROLE");
modifier onlyAdmin() {
checkAdmin(_msgSender());
_;
}
modifier onlyExecutor() {
checkExecutor(_msgSender());
_;
}
// solhint-disable-next-line func-name-mixedcase
function __AdminExecutor_init(address admin, address startingExecutor) internal onlyInitializing {
__AccessControl_init();
__Pausable_init();
__AdminExecutor_init_unchained(admin, startingExecutor);
}
// solhint-disable-next-line func-name-mixedcase
function __AdminExecutor_init_unchained(address admin, address startingExecutor) internal onlyInitializing {
_grantRole(DEFAULT_ADMIN_ROLE, admin);
// DEFAULT_ADMIN_ROLE already is admin for executor by default, so no need for _setRoleAdmin
if (startingExecutor != address(0x0)) {
_grantRole(EXECUTOR_ROLE, startingExecutor);
}
}
function pause() public onlyAdmin {
_pause();
}
function unpause() public onlyAdmin {
_unpause();
}
/// @dev Check is a particular account has executor permissions. Reverts if not the case.
/// @param account the account to check
function checkExecutor(address account) public view {
_checkRole(EXECUTOR_ROLE, account);
}
function checkAdmin(address account) public view {
_checkRole(DEFAULT_ADMIN_ROLE, account);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { ConditionID, QuestionID } from "./CTHelpers.sol";
struct ParlayLegs {
/// @dev list of unique questionIds to be used as legs in the parlay
QuestionID[] questionIds;
/// @dev the outcome index in each leg of the parlay
uint256[] indices;
/// @dev number of outcomes for each questionId. Needed to reconstruct the conditionIds
uint256[] outcomeSlotCounts;
}
interface IParlayConditionalTokensEvents {
event ParlayConditionLegs(
ConditionID indexed conditionId,
QuestionID indexed questionId,
address indexed legOracle,
uint256 legQuestionIdMask,
ParlayLegs legs
);
}
interface IParlayConditionalTokens {
/// @dev Prepare a condition that is a parlay of several other conditions as legs of the parlay.
/// @param legOracle the condition oracle providing resolutions for all the conditions in the parlay
/// @param legQuestionIdMask When considering uniqueness and ordering, this
/// bitmask will be applied to the questionId. This can be used to restrict
/// parlays to only be possible across different events.
/// @param legs list of all legs
/// @return parlayQuestionId the synthetic questionID of the parlay
/// @return parlayConditionId the conditionId of the parlay
function prepareParlayCondition(address legOracle, uint256 legQuestionIdMask, ParlayLegs calldata legs)
external
returns (QuestionID parlayQuestionId, ConditionID parlayConditionId);
/// @dev report parlay payouts for a questionId in a permissionless manner.
/// The payout is deterministically decided by the payouts of the legs of the parlay.
/// If not all leg conditions are resolved, will revert.
/// If parlay condition is already resolved, will do nothing (idempotent)
/// @param parlayQuestionId the parlay id (returned when creating the parlay condition)
function reportParlayPayouts(QuestionID parlayQuestionId) external;
function batchReportParlayPayouts(QuestionID[] calldata parlayQuestionIds) external;
/// @dev Calculates the derived Parlay QuestionID from underlying conditional token leg conditions
/// @param legOracle the oracle address used for all the underlying legs
/// @param legQuestionIds all the leg questionIds
/// @param legQuestionIdMask When considering uniqueness and ordering, this
/// bitmask will be applied to the questionId. This can be used to restrict
/// parlays to only be possible across different events.
/// @param legIndices the outcome index in each leg of the parlay
/// @return parlayQuestionId the derived QuestionID for the parlay
function getParlayQuestionId(
address legOracle,
QuestionID[] calldata legQuestionIds,
uint256 legQuestionIdMask,
uint256[] calldata legIndices
) external pure returns (QuestionID);
function getParlayConditionId(QuestionID parlayQuestionId) external pure returns (ConditionID);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
// Note on libraries. If any functions are not `internal`, then contracts that
// use the libraries, must be linked.
library ArrayMath {
function sum(uint256[] memory values) internal pure returns (uint256) {
uint256 result = 0;
for (uint256 i = 0; i < values.length; i++) {
result += values[i];
}
return result;
}
}
/// @dev Math with saturation/clamping for overflow/underflow handling
library ClampedMath {
/// @dev min(upper, max(lower, x))
function clampBetween(uint256 x, uint256 lower, uint256 upper) internal pure returns (uint256) {
unchecked {
return x < lower ? lower : (x > upper ? upper : x);
}
}
/// @dev max(0, a - b)
function subClamp(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
return a > b ? a - b : 0;
}
}
/// @dev min(type(uint256).max, max(0, a + b))
function addClamp(uint256 a, int256 b) internal pure returns (uint256) {
unchecked {
if (b < 0) {
// The absolute value of type(int256).min is not representable
// in int256, so have to dance about with the + 1
uint256 positiveB = uint256(-(b + 1)) + 1;
return (a > positiveB) ? (a - positiveB) : 0;
} else {
return type(uint256).max - a > uint256(b) ? a + uint256(b) : type(uint256).max;
}
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControlUpgradeable {
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/MathUpgradeable.sol";
/**
* @dev String operations.
*/
library StringsUpgradeable {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = MathUpgradeable.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, MathUpgradeable.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
* constructor.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: setting the version to 255 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { MarketErrors } from "./MarketErrors.sol";
import { IFundingPoolV1 } from "../funding/IFundingPoolV1.sol";
import { IUpdateFairPrices } from "./IUpdateFairPrices.sol";
/// @dev Interface evolution is done by creating new versions of the interfaces
/// and making sure that the derived MarketMaker supports all of them.
/// Alternatively we could have gone with breaking the interface down into each
/// function one by one and checking each function selector. This would
/// introduce a lot more code in `supportsInterface` which is called often, so
/// it's easier to keep track of incremental evolution than all the constituent
/// pieces
interface IMarketMakerV1 is IFundingPoolV1, IUpdateFairPrices, MarketErrors {
event MarketBuy(
address indexed buyer,
uint256 investmentAmount,
uint256 feeAmount,
uint256 indexed outcomeIndex,
uint256 outcomeTokensBought
);
event MarketSell(
address indexed seller,
uint256 returnAmount,
uint256 feeAmount,
uint256 indexed outcomeIndex,
uint256 outcomeTokensSold
);
event MarketSpontaneousPrices(uint256[] spontaneousPrices);
function removeFunding(uint256 sharesToBurn) external returns (uint256 collateral, uint256[] memory sendAmounts);
function buyFor(address receiver, uint256 investmentAmount, uint256 outcomeIndex, uint256 minOutcomeTokensToBuy)
external
returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices);
function buy(uint256 investmentAmount, uint256 outcomeIndex, uint256 minOutcomeTokensToBuy)
external
returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices);
function sell(uint256 returnAmount, uint256 outcomeIndex, uint256 maxOutcomeTokensToSell)
external
returns (uint256 outcomeTokensSold);
function removeCollateralFundingOf(address ownerAndReceiver, uint256 sharesToBurn)
external
returns (uint256[] memory sendAmounts, uint256 collateral);
function removeAllCollateralFunding(address[] calldata funders)
external
returns (uint256 totalSharesBurnt, uint256 totalCollateralRemoved);
function isHalted() external view returns (bool);
function calcBuyAmount(uint256 investmentAmount, uint256 outcomeIndex)
external
view
returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices);
function calcSellAmount(uint256 returnAmount, uint256 outcomeIndex) external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IMarketMakerV1 } from "./IMarketMaker.sol";
import { FeeProfileID } from "../funding/FeeDistributor.sol";
interface IMarketMakerV1_2 is IMarketMakerV1 {
/// @dev Same as the simpler buyFor, except using a custom feeProfile for how to distribute the fees
/// @param receiver Which account receives te bought conditional tokens
/// @param investmentAmount How much collateral to spend on the order
/// @param outcomeIndex Which outcome to purchase
/// @param minOutcomeTokensToBuy Minimal amount of conditional tokens expected to be received. Controls max slippage
/// @param extraFeeDecimal If buyer wants to deposit any extra fees on top of the ones set by the market
/// @param feeProfileId Fee Profile Id determines how overall fees are ultimately distributed to beneficiaries
function buyFor(
address receiver,
uint256 investmentAmount,
uint256 outcomeIndex,
uint256 minOutcomeTokensToBuy,
uint256 extraFeeDecimal,
FeeProfileID feeProfileId
) external returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices);
function calcBuyAmount(uint256 investmentAmount, uint256 indexOut, uint256 extraFeeDecimal)
external
view
returns (uint256 outcomeTokensBought, uint256 feeAmount, uint256[] memory spontaneousPrices);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IConditionalTokensV1_2 } from "../conditions/IConditionalTokensV1_2.sol";
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
struct MarketAddressParams {
IConditionalTokensV1_2 conditionalTokens;
IERC20Metadata collateralToken;
address parentPool;
address priceOracle;
address conditionOracle;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IERC1155Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC1155/IERC1155Upgradeable.sol";
import { ConditionID, QuestionID } from "./CTHelpers.sol";
import { ConditionalTokensErrors } from "./ConditionalTokensErrors.sol";
/// @title Events emitted by conditional tokens
/// @dev Minimal interface to be used for blockchain indexing (e.g subgraph)
interface IConditionalTokensEvents {
/// @dev Emitted upon the successful preparation of a condition.
/// @param conditionId The condition's ID. This ID may be derived from the
/// other three parameters via ``keccak256(abi.encodePacked(oracle,
/// questionId, outcomeSlotCount))``.
/// @param oracle The account assigned to report the result for the prepared condition.
/// @param questionId An identifier for the question to be answered by the oracle.
/// @param outcomeSlotCount The number of outcome slots which should be used
/// for this condition. Must not exceed 256.
event ConditionPreparation(
ConditionID indexed conditionId, address indexed oracle, QuestionID indexed questionId, uint256 outcomeSlotCount
);
event ConditionResolution(
ConditionID indexed conditionId,
address indexed oracle,
QuestionID indexed questionId,
uint256 outcomeSlotCount,
uint256[] payoutNumerators
);
/// @dev Emitted when a position is successfully split.
event PositionSplit(
address indexed stakeholder, IERC20 collateralToken, ConditionID indexed conditionId, uint256 amount
);
/// @dev Emitted when positions are successfully merged.
event PositionsMerge(
address indexed stakeholder, IERC20 collateralToken, ConditionID indexed conditionId, uint256 amount
);
/// @notice Emitted when a subset of outcomes are redeemed for a condition
event PayoutRedemption(
address indexed redeemer,
IERC20 indexed collateralToken,
ConditionID conditionId,
uint256[] indices,
uint256 payout
);
}
interface IConditionalTokens is IERC1155Upgradeable, IConditionalTokensEvents, ConditionalTokensErrors {
function prepareCondition(address oracle, QuestionID questionId, uint256 outcomeSlotCount)
external
returns (ConditionID);
function reportPayouts(QuestionID questionId, uint256[] calldata payouts) external;
function batchReportPayouts(
QuestionID[] calldata questionIDs,
uint256[] calldata payouts,
uint256[] calldata outcomeSlotCounts
) external;
function splitPosition(IERC20 collateralToken, ConditionID conditionId, uint256 amount) external;
function mergePositions(IERC20 collateralToken, ConditionID conditionId, uint256 amount) external;
function redeemPositionsFor(
address receiver,
IERC20 collateralToken,
ConditionID conditionId,
uint256[] calldata indices,
uint256[] calldata quantities
) external returns (uint256);
function redeemAll(IERC20 collateralToken, ConditionID[] calldata conditionIds, uint256[] calldata indices)
external;
function redeemAllOf(
address ownerAndReceiver,
IERC20 collateralToken,
ConditionID[] calldata conditionIds,
uint256[] calldata indices
) external returns (uint256 totalPayout);
function balanceOfCondition(address account, IERC20 collateralToken, ConditionID conditionId)
external
view
returns (uint256[] memory);
function isResolved(ConditionID conditionId) external view returns (bool);
function getPositionIds(IERC20 collateralToken, ConditionID conditionId) external view returns (uint256[] memory);
// TODO: This should be ok to add to the first interface, since we currently don't use the interface id directly anywhere,
// and the very first version of the contract did support this function.
/// @dev number of outcome slots in a condition
function getOutcomeSlotCount(ConditionID conditionId) external view returns (uint256);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev _Available since v3.1._
*/
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
/**
* @dev Handles the receipt of a single ERC1155 token type. This function is
* called at the end of a `safeTransferFrom` after the balance has been updated.
*
* NOTE: To accept the transfer, this must return
* `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
* (i.e. 0xf23a6e61, or its own function selector).
*
* @param operator The address which initiated the transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param id The ID of the token being transferred
* @param value The amount of tokens being transferred
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
/**
* @dev Handles the receipt of a multiple ERC1155 token types. This function
* is called at the end of a `safeBatchTransferFrom` after the balances have
* been updated.
*
* NOTE: To accept the transfer(s), this must return
* `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
* (i.e. 0xbc197c81, or its own function selector).
*
* @param operator The address which initiated the batch transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param ids An array containing ids of each token being transferred (order and length must match values array)
* @param values An array containing amounts of each token being transferred (order and length must match ids array)
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol)
pragma solidity ^0.8.0;
import "../IERC1155ReceiverUpgradeable.sol";
import "../../../utils/introspection/ERC165Upgradeable.sol";
import "../../../proxy/utils/Initializable.sol";
/**
* @dev _Available since v3.1._
*/
abstract contract ERC1155ReceiverUpgradeable is Initializable, ERC165Upgradeable, IERC1155ReceiverUpgradeable {
function __ERC1155Receiver_init() internal onlyInitializing {
}
function __ERC1155Receiver_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return interfaceId == type(IERC1155ReceiverUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @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 up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (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; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 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.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
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 (rounding == Rounding.Up && 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 down.
*
* 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* 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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* 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 10, 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 + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { ERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { IFundingPoolV1_1, IFundingPoolV1 } from "./IFundingPoolV1_1.sol";
import { FundingMath } from "./FundingMath.sol";
import { ArrayMath, ClampedMath } from "../Math.sol";
/// @dev A contract with the necessary storage to keep track of funding. Should
/// not be used as a standalone contract, but like a mixin
abstract contract FundingPool is IFundingPoolV1_1, ERC20Upgradeable {
using Math for uint256;
using ArrayMath for uint256[];
using SafeERC20 for IERC20Metadata;
IERC20Metadata public collateralToken;
/// @inheritdoc IFundingPoolV1
uint256 public collectedFees;
/// @dev Keeps track of total collateral used to enter the current liquidity
/// position of the funder. It is increased by the collateral amount every
/// time the funder funds, and then reduced proportionally to how many LP
/// shares are withdrawn during defunding. This can be considered the "cost
/// basis" of the lp shares of each funder
mapping(address => uint256) private funderCostBasis;
/// @dev Total collateral put into funding the current LP shares
uint256 private totalFunderCostBasis;
/// @dev By default fees are no longer withdrawable - it's up to
/// implementation to decide what to do with the fees and how to distribute
/// them
function withdrawFees(address /* funder */ ) public pure returns (uint256) {
return 0;
}
/// @dev By default fees are no longer withdrawable - it's up to
/// implementation to decide what to do with the fees and how to distribute
/// them
function feesWithdrawableBy(address /* account */ ) public pure returns (uint256) {
return 0;
}
/// @inheritdoc IFundingPoolV1
function reserves() public view returns (uint256 collateral) {
uint256 totalCollateral = collateralToken.balanceOf(address(this));
uint256 fees = collectedFees;
assert(totalCollateral >= fees);
return totalCollateral - fees;
}
// solhint-disable-next-line func-name-mixedcase
function __FundingPool_init(IERC20Metadata _collateralToken) internal onlyInitializing {
__ERC20_init("", "");
__FundingPool_init_unchained(_collateralToken);
}
// solhint-disable-next-line func-name-mixedcase
function __FundingPool_init_unchained(IERC20Metadata _collateralToken) internal onlyInitializing {
if (_collateralToken.decimals() > 18) revert ExcessiveCollateralDecimals();
collateralToken = _collateralToken;
}
/// @dev Burns the LP shares corresponding to a particular owner account
/// Also note that _beforeTokenTransfer will be invoked to make sure the fee
/// bookkeeping is updated for the owner.
/// @param owner Account to whom the LP shares belongs to.
/// @param sharesToBurn Portion of LP pool to burn.
function _burnSharesOf(address owner, uint256 sharesToBurn) internal {
// slither-disable-next-line dangerous-strict-equalities
if (sharesToBurn == 0) revert InvalidBurnAmount();
uint256 costBasisReduction =
FundingMath.calcCostBasisReduction(balanceOf(owner), sharesToBurn, funderCostBasis[owner]);
funderCostBasis[owner] -= costBasisReduction;
totalFunderCostBasis -= costBasisReduction;
_burn(owner, sharesToBurn);
}
function _mintSharesFor(address receiver, uint256 collateralAdded, uint256 poolValue)
internal
returns (uint256 sharesMinted)
{
if (collateralAdded == 0) revert InvalidFundingAmount();
sharesMinted = FundingMath.calcFunding(collateralAdded, totalSupply(), poolValue);
// Ensure this stays below type(uint128).max to avoid overflow in liquidity calculations
uint256 costBasisAfter = funderCostBasis[receiver] + collateralAdded;
if (costBasisAfter > type(uint128).max) revert ExcessiveFunding();
funderCostBasis[receiver] = costBasisAfter;
totalFunderCostBasis += collateralAdded;
address sender = _msgSender();
collateralToken.safeTransferFrom(sender, address(this), collateralAdded);
// Ensure total shares for funding does not exceed type(uint128).max to avoid overflow
uint256 sharesAfter = balanceOf(receiver) + sharesMinted;
if (sharesAfter > type(uint128).max) revert ExcessiveFunding();
_mint(receiver, sharesMinted);
emit FundingAdded(sender, receiver, collateralAdded, sharesMinted);
}
/// @dev adjust cost basis for a funder
function _adjustCostBasis(address funder, uint256 adjustment) internal {
funderCostBasis[funder] = funderCostBasis[funder] + adjustment;
totalFunderCostBasis = totalFunderCostBasis + adjustment;
}
/// @dev Sets aside some collateral as fees
function _retainFees(uint256 collateralFees) internal {
if (collateralFees > reserves()) revert FeesExceedReserves();
if (collateralFees == 0) return;
collectedFees += collateralFees;
emit FeesRetained(collateralFees);
}
/// @dev put fees back into reserves
function _unlockFees(uint256 collateralFees) internal {
if (collateralFees > collectedFees) revert FeesExceedCollected();
collectedFees -= collateralFees;
}
/// @dev How much collateral was spent by all funders to obtain their current shares
function getTotalFunderCostBasis() public view returns (uint256) {
return totalFunderCostBasis;
}
function getFunderCostBasis(address funder) public view returns (uint256) {
return funderCostBasis[funder];
}
// solhint-disable-next-line ordering
uint256[50] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IChildFundingPoolV1 } from "./IChildFundingPoolV1.sol";
import { IParentFundingPoolV1 } from "./IParentFundingPoolV1.sol";
import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
/// @dev A Mixin contract that provides a basic implementation of the IChildFundingPoolV1 interface
abstract contract ChildFundingPool is Initializable, IChildFundingPoolV1 {
using ERC165Checker for address;
address private _parent;
bytes4 internal constant PARENT_FUNDING_POOL_INTERFACE_ID = 0xd0632e9a;
function getParentPool() public view returns (address) {
return _parent;
}
// solhint-disable-next-line func-name-mixedcase
function __ChildFundingPool_init(address parentPool) internal onlyInitializing {
__ChildFundingPool_init_unchained(parentPool);
}
// solhint-disable-next-line func-name-mixedcase
function __ChildFundingPool_init_unchained(address parentPool) internal onlyInitializing {
assert(address(_parent) == address(0x0));
if (parentPool != address(0x0) && !parentPool.supportsInterface(PARENT_FUNDING_POOL_INTERFACE_ID)) {
revert NotAParentPool(parentPool);
}
_parent = parentPool;
emit ParentPoolAdded(parentPool);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { AdminExecutorAccessUpgradeable } from "../AdminExecutorAccess.sol";
type FeeProfileID is uint256;
interface FeeDistributorErrors {
error FeeProfileNotFound(FeeProfileID);
error InvalidFeeProfile();
/// @dev Error when a beneficiary gets nothing because the recursive
/// portions have left too little to distribute. Typically should wait
/// longer before distributing to increase the fund size.
error UnfairDistribution();
error InvalidAmountArray();
}
interface IFeeDistributorEvents {
struct FeeProfile {
/// @dev portion of funds out of 256 that should be sent to the child.
/// The rest gets directed to the beneficiary
uint8 childPortion;
address beneficiary;
FeeProfileID childProfile;
}
event FeeProfileCreated(FeeProfileID indexed profileId, FeeProfile profile);
}
/// @dev A pool of collateral that can be distributed to beneficiaries according
/// to some fee profile - what percentage of the amount goes to whom. This is
/// achieved by chaining profiles together, where a portion of the collateral
/// for a profile gets sent to a beneficiary and the rest go to another profile,
/// and so on until all collateral is distributed.
///
/// Creating new profiles is permissionless.
contract FeeDistributor is IFeeDistributorEvents, FeeDistributorErrors, AdminExecutorAccessUpgradeable {
using SafeERC20 for IERC20;
using Math for uint256;
using EnumerableSet for EnumerableSet.UintSet;
struct Transfer {
FeeProfileID profileId;
uint256 amount;
}
FeeProfileID public constant NULL_PROFILE_ID = FeeProfileID.wrap(uint256(0x0));
uint256 private constant PORTION_DIVISOR = 256;
mapping(FeeProfileID => FeeProfile) public profiles;
mapping(IERC20 => mapping(FeeProfileID => uint256)) public balances;
EnumerableSet.UintSet private approvedProfileIds;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(address admin) {
// The contract is not meant to be upgradeable or run behind a proxy,
// but uses upgradeable base contracts because it shares some base
// classes with other contracts that need to be behind a proxy
initialize(admin, address(0x0));
_disableInitializers();
}
/// @dev Create a new fee profile
/// @return profileId the unique ID that identifies the profile
function addProfile(FeeProfile calldata profile) external returns (FeeProfileID profileId) {
// Do not allow the last profile in a chain not to have everything allocated to the beneficiary
if (FeeProfileID.unwrap(profile.childProfile) == 0x0 && profile.childPortion > 0) {
revert InvalidFeeProfile();
}
profileId = FeeProfileID.wrap(uint256(keccak256(abi.encode(profile))));
profiles[profileId] = profile;
emit FeeProfileCreated(profileId, profile);
}
function _transferToProfile(IERC20 collateralToken, FeeProfileID profileId, uint256 amount) internal {
if (profiles[profileId].beneficiary == address(0x0)) revert FeeProfileNotFound(profileId);
balances[collateralToken][profileId] += amount;
}
function transferToProfile(IERC20 collateralToken, FeeProfileID profileId, uint256 amount) external {
_transferToProfile(collateralToken, profileId, amount);
collateralToken.safeTransferFrom(msg.sender, address(this), amount);
}
function transferToProfiles(IERC20 collateralToken, FeeProfileID[] calldata profileIds, uint256[] calldata amounts)
external
{
if (profileIds.length != amounts.length) revert InvalidAmountArray();
uint256 total = 0;
for (uint256 i = 0; i < amounts.length; i++) {
uint256 amount = amounts[i];
_transferToProfile(collateralToken, profileIds[i], amount);
total += amount;
}
collateralToken.safeTransferFrom(msg.sender, address(this), total);
}
function distributeFees(IERC20 collateralToken, FeeProfileID profileID)
external
returns (uint256 totalTransferred)
{
mapping(FeeProfileID => uint256) storage tokenBalances = balances[collateralToken];
// Go down the entire chain of profiles and distribute the fees to all beneficiaries
uint256 childAmount = 0;
while (FeeProfileID.unwrap(profileID) != 0x0) {
// Read these together to save on gas cost (should be in same slot)
uint256 childPortion = profiles[profileID].childPortion;
address beneficiary = profiles[profileID].beneficiary;
uint256 balance = tokenBalances[profileID] + childAmount;
if (balance == 0) break;
// Using ceilDiv here, so that beneficiaries earlier in the
// chain don't have an incentive to do this too early, to starve
// beneficiaries further down the line
childAmount = (balance * childPortion).ceilDiv(PORTION_DIVISOR);
uint256 transferAmount = balance - childAmount;
if (transferAmount == 0) revert UnfairDistribution();
totalTransferred += transferAmount;
// All balances are distributed, either to beneficiary or child profile
tokenBalances[profileID] = 0;
// Re-entrancy here is ok, because the state of the contract at that
// moment is "finalized" relative to the current `profileID`. Any
// subsequent state variables that are modified, are for other
// profileIDs which haven't been touched yet. The loop is just an
// optimization to save us from manually calling this function for
// all profiles down the chain one after another.
// slither-disable-next-line reentrancy-no-eth
collateralToken.safeTransfer(beneficiary, transferAmount);
profileID = profiles[profileID].childProfile;
}
// Fee profile that leaves something unallocated should not be allowed
assert(childAmount == 0);
}
function approveProfile(FeeProfileID profileId) external onlyAdmin {
if (profiles[profileId].beneficiary == address(0x0)) revert FeeProfileNotFound(profileId);
approvedProfileIds.add(FeeProfileID.unwrap(profileId));
}
function unapproveProfile(FeeProfileID profileId) external onlyAdmin {
if (profiles[profileId].beneficiary == address(0x0)) revert FeeProfileNotFound(profileId);
approvedProfileIds.remove(FeeProfileID.unwrap(profileId));
}
function approvedProfiles() external view returns (FeeProfileID[] memory profileIds) {
uint256[] memory ids = approvedProfileIds.values();
assembly ("memory-safe") {
profileIds := ids
}
}
function initialize(address admin, address executor) private initializer {
__AdminExecutor_init(admin, executor);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { ArrayMath, ClampedMath } from "../Math.sol";
import { AmmErrors } from "./AmmErrors.sol";
import { UD60x18, UNIT, ZERO, exp, convert, unwrap, wrap } from "@prb/math/UD60x18.sol";
library UD60x18Extensions {
function addScalar(UD60x18 x, uint256 y) internal pure returns (UD60x18 result) {
result = wrap(unwrap(x) + y);
}
function subScalar(UD60x18 x, uint256 y) internal pure returns (UD60x18 result) {
result = wrap(unwrap(x) - y);
}
function mulScalar(UD60x18 x, uint256 y) internal pure returns (UD60x18 result) {
result = wrap(unwrap(x) * y);
}
function divScalar(UD60x18 x, uint256 y) internal pure returns (UD60x18 result) {
result = wrap(unwrap(x) / y);
}
function ceilDivScalar(UD60x18 x, uint256 y) internal pure returns (UD60x18 result) {
result = wrap(Math.ceilDiv(unwrap(x), y));
}
function ceilDiv(UD60x18 x, UD60x18 y) internal pure returns (UD60x18 result) {
// (x - 1) / (y + 1)
result = unwrap(x) == 0 ? ZERO : addScalar(subScalar(x, 1).div(y), 1);
}
}
library AmmMath {
using Math for uint256;
using ClampedMath for uint256;
using ArrayMath for uint256[];
using UD60x18Extensions for UD60x18;
uint256 internal constant PRECISION_DECIMALS = 18;
uint256 internal constant ONE_DECIMAL = 10 ** PRECISION_DECIMALS;
// The smallest exponent in the slippage formula for e ^ ((a d) / t)
// Determined empirically
UD60x18 internal constant MIN_EXPONENT = UD60x18.wrap(10 ** 6);
// Max exponent possible that would not overflow slippage calculations
UD60x18 internal constant MAX_EXPONENT = UD60x18.wrap(132e18);
/// @dev Calculate the pool value given token balances and a set of fair prices
/// @param balances The current balances of each outcome token in a pool
/// @param fairPriceDecimals normalized prices for each outcome token
/// provided externally. Any missing trailing prices are assumed to be 0.
/// @return poolValue total sum of value of all tokens
function calcPoolValue(uint256[] memory balances, uint256[] memory fairPriceDecimals)
internal
pure
returns (uint256 poolValue)
{
// Assume any missing trailing prices are all 0
if (fairPriceDecimals.length > balances.length) revert AmmErrors.BalancePriceLengthMismatch();
uint256 totalValue = 0;
uint256 normalization = 0;
for (uint256 i = 0; i < fairPriceDecimals.length; ++i) {
totalValue += fairPriceDecimals[i] * balances[i];
normalization += fairPriceDecimals[i];
}
poolValue = totalValue.ceilDiv(normalization);
}
/// @dev Calculate the pool value given token balances and a set of fair prices, as well as extra collateral
/// @param balances The current balances of each outcome token in a pool
/// @param fairPriceDecimals normalized prices for each outcome token
/// provided externally. Any missing trailing prices are assumed to be 0.
/// @param collateralBalance extra collateral balance
/// @return poolValue total sum of value of all tokens
function calcPoolValue(uint256[] memory balances, uint256[] memory fairPriceDecimals, uint256 collateralBalance)
internal
pure
returns (uint256 poolValue)
{
return calcPoolValue(balances, fairPriceDecimals) + collateralBalance;
}
/// @dev Calculate how many tokens result from exchanging at a flat rate. A
/// minimum price is used to value output tokens, but not input tokens.
/// Minimum price for output tokens avoids giving out too many if the price
/// is very small. The minimum price is not symmetric, because we don't
/// want to overvalue tokens that are coming in, and end up giving out more
/// output tokens as a result
/// @param tokensMintedDecimal quantity of input tokens to be exchanged
/// @param fairPriceInDecimal price of input tokens
/// @param fairPriceOutDecimal price of output tokens
/// @return tokensOutDecimal quantity of tokens resulting from the exchange
function calcElementwiseFairAmount(
uint256 tokensMintedDecimal,
uint256 fairPriceInDecimal,
uint256 fairPriceOutDecimal
) internal pure returns (uint256 tokensOutDecimal) {
assert(fairPriceOutDecimal > 0);
tokensOutDecimal = (tokensMintedDecimal * fairPriceInDecimal) / fairPriceOutDecimal;
}
uint256 internal constant MIN_FLATNESS = 0.1e18; // flatness parameter cannot be lower than 0.01
uint256 internal constant MAX_FLATNESS = 2.0e18; // flatness parameter cannot exceed 2
// The lower the price, the higher the flatness of the curve (to decrease slippage)
// The two are inversly related.
uint256 internal constant PRICE_WITH_MAX_FLATNESS = 0.05e18;
uint256 internal constant PRICE_WITH_MIN_FLATNESS = 0.5e18;
uint256 internal constant PRICE_FLATNESS_LUT_INCREMENT = 0.05e18;
/// @dev The new algorithm has a flatness parameter, that reduces slippage
/// when balance is close to target. At flatness == 1.0 the curve is
/// equivalent to e^x, and flatness == 2.0, the curve is equivalent to
/// tanh(x), and as flatness approaches 0, the curve approximates the
/// constant product curve.
/// The flatness is adjusted based on token price - when a token is cheap, a
/// larger amount of the token is taken from the balance. When a cheap token
/// is bought, more tokens are removed from balance and more slippage
/// occurs. In order to encourage equal bets on both sides, the slippage
/// should be close for "typical" size bets. The values are derived for bets
/// that are 1% of liquidity for a market.
function calculateFlatness(uint256 fairPriceDecimal) internal pure returns (uint256 flatnessDecimal) {
// Lookup table from price to the flatness parameter. The flatness is
// derived such that the initial slippage for a low-price p token is
// equivalent to slippage that you would get from a higher-price (1 - p)
// token.
uint256[10] memory lut = [
uint256(2.0e18), // {0.05, 2.0302},
uint256(1.83963e18), // {0.1, 1.83963},
uint256(1.69173e18), // {0.15, 1.69173},
uint256(1.54082e18), // {0.2, 1.54082},
uint256(1.37613e18), // {0.25, 1.37613},
uint256(1.19123e18), // {0.3, 1.19123},
uint256(0.979886e18), // {0.35, 0.979886},
uint256(0.734672e18), // {0.4, 0.734672},
uint256(0.445846e18), // {0.45, 0.445846},
uint256(0.1e18) // {0.5, 0.1}
];
// Price that is clamped to the min and max, and also offset such that
// PRICE_WITH_MAX_FLATNESS gets remapped to 0 for indexing
uint256 remappedPriceDecimal =
fairPriceDecimal.clampBetween(PRICE_WITH_MAX_FLATNESS, PRICE_WITH_MIN_FLATNESS) - PRICE_WITH_MAX_FLATNESS;
// index into lut and linearly interpolate
uint256 index = remappedPriceDecimal / PRICE_FLATNESS_LUT_INCREMENT;
uint256 blendAmount = remappedPriceDecimal % PRICE_FLATNESS_LUT_INCREMENT;
uint256 nextIndex = Math.min(9, index + 1);
flatnessDecimal = lut[index] - (blendAmount * (lut[index] - lut[nextIndex])) / PRICE_FLATNESS_LUT_INCREMENT;
}
/// @dev calculate the proportion of spread attributed to the output token.
/// The less balance we have than the target, the more the spread since we
/// are losing the token.
function applyOutputSlippage(uint256 balance, uint256 tokensOut, uint256 targetBalance, uint256 flatnessDecimal)
internal
pure
returns (uint256 adjustedTokensDecimal)
{
uint256 tokensBelowTarget;
{
// How many tokens from tokensOut that are above the target balance. Exchanged 1:1
uint256 tokensAboveTarget = Math.min(tokensOut, balance - Math.min(targetBalance, balance));
adjustedTokensDecimal = tokensAboveTarget * ONE_DECIMAL;
balance -= tokensAboveTarget;
tokensBelowTarget = tokensOut - tokensAboveTarget;
}
// Tokens that are now bringing us below target are run through amm to introduce slippage
if (tokensBelowTarget > 0) {
if (balance == 0) {
return adjustedTokensDecimal;
}
assert(balance <= targetBalance);
assert(flatnessDecimal >= MIN_FLATNESS);
assert(flatnessDecimal <= MAX_FLATNESS);
// a = flatness
// b = balance
// d = tokensBelowTarget (how many tokens we need to exchange through amm curve)
// t = targetBalance
// Need to calculate new balance:
// E = e ^ ((a d) / t)
// L = (b + a t - a b)
// newBalance = (a b t) / (a b + E L - b)
UD60x18 balanceDecimal = convert(balance);
UD60x18 flatnessTimesBalanceDecimal = UD60x18.wrap(flatnessDecimal * balance);
// (a b t)
UD60x18 numeratorDecimal = flatnessTimesBalanceDecimal.mulScalar(targetBalance);
// E = e ^ ((a d) / t)
UD60x18 flatnessTimesTokensDecimal = UD60x18.wrap(flatnessDecimal * tokensBelowTarget);
UD60x18 exponent = flatnessTimesTokensDecimal.divScalar(targetBalance);
if (exponent.gte(MAX_EXPONENT)) {
return adjustedTokensDecimal + (balance - 1) * ONE_DECIMAL;
}
// L = (b + a t - a b)
UD60x18 largeTermDecimal =
balanceDecimal.add(wrap(flatnessDecimal * targetBalance)).sub(flatnessTimesBalanceDecimal);
UD60x18 newBalanceDecimal;
if (exponent.lt(MIN_EXPONENT)) {
// At extremely small values of the exponent, e^x, is close to 1 + x + x^2 / 2
// Rewriting:
// E L
// = (e ^ ((a d) / t)) L
// =~ (1 + ((a d) / t) + ((a d) / t)^2 / 2 ) L
// = L + L a d / t + L ((a d) / t)^2 / 2
// = L + L a d / t + L (a d)^2 / 2 t^2
UD60x18 intermediateTermDecimal = largeTermDecimal;
largeTermDecimal = largeTermDecimal.mul(flatnessTimesTokensDecimal);
intermediateTermDecimal = intermediateTermDecimal.add(largeTermDecimal.divScalar(targetBalance));
intermediateTermDecimal = intermediateTermDecimal.add(
largeTermDecimal.mul(flatnessTimesTokensDecimal).divScalar(2 * targetBalance * targetBalance)
);
// (a b + E L - b)
UD60x18 denominatorDecimal =
flatnessTimesBalanceDecimal.add(intermediateTermDecimal).sub(balanceDecimal);
newBalanceDecimal = numeratorDecimal.ceilDiv(denominatorDecimal);
} else if (exponent.lt(convert(80))) {
UD60x18 exponentialTermDecimal = exp(exponent);
UD60x18 intermediateTermDecimal = exponentialTermDecimal.mul(largeTermDecimal);
// (a b + E L - b)
UD60x18 denominatorDecimal =
flatnessTimesBalanceDecimal.add(intermediateTermDecimal).sub(balanceDecimal);
newBalanceDecimal = numeratorDecimal.ceilDiv(denominatorDecimal);
} else {
uint256 exponentialTerm = convert(exp(exponent));
// (a b + E L - b)
uint256 denominator = convert(flatnessTimesBalanceDecimal)
+ Math.mulDiv(exponentialTerm, unwrap(largeTermDecimal), ONE_DECIMAL) - balance;
newBalanceDecimal = wrap(unwrap(numeratorDecimal).ceilDiv(denominator));
}
// Don't allow balance to go to 0;
newBalanceDecimal = newBalanceDecimal.lt(UNIT) ? UNIT : newBalanceDecimal;
assert(newBalanceDecimal.lte(balanceDecimal));
adjustedTokensDecimal += unwrap(balanceDecimal.sub(newBalanceDecimal));
}
}
function applyOutputSlippage(uint256 balance, uint256 tokensOut, uint256 targetBalance)
internal
pure
returns (uint256 adjustedTokensDecimal)
{
return applyOutputSlippage(balance, tokensOut, targetBalance, ONE_DECIMAL);
}
/// @dev calculate the output spread. This is equivalent to output slippage
/// assuming an infinitessimal trade size. tokensOutDecimal does not
/// influence the amount of spread.
function applyOutputSpread(
uint256 balance,
uint256 tokensOutDecimal,
uint256 targetBalance,
uint256 flatnessDecimal
) internal pure returns (uint256) {
// Only apply slippage if balance below target
if (balance < targetBalance) {
// a = flatness
// b = balance
// d = tokensOut
// t = targetBalance
// b d (b + a t - a b) / t^2
uint256 largeTermDecimal =
balance * ONE_DECIMAL + flatnessDecimal * targetBalance - flatnessDecimal * balance;
uint256 numeratorDecimal = Math.mulDiv(balance * tokensOutDecimal, largeTermDecimal, ONE_DECIMAL);
uint256 denominator = targetBalance * targetBalance;
return numeratorDecimal / denominator;
} else {
return tokensOutDecimal;
}
}
function applyOutputSpread(uint256 balance, uint256 tokensOutDecimal, uint256 targetBalance)
internal
pure
returns (uint256)
{
return applyOutputSpread(balance, tokensOutDecimal, targetBalance, ONE_DECIMAL);
}
/// @dev Calculate the amount of tokensOut given the amount of tokensMinted.
/// This code is generic with respect to how many outcomes have prices.
/// @param tokensMinted amount of tokens minted that we are trying to exchange
/// @param indexOut the index of the outcome token we are trying to buy
/// @param targetBalance the target balance of each outcome token. We assume
/// equal target balance is optimal, so it can be represented by a single
/// value rather than an array. All token balances should ideally equal this
/// value
/// @param collateralBalance Extra collateral available to mint more tokens
/// @param balances The current balances of each outcome token in the pool
/// @param fairPriceDecimals normalized prices for each outcome token
/// provided externally. Any missing trailing prices are assumed to be 0.
/// @return tokensOut how many tokens are swapped for the other minted tokens
/// @return newPoolValue given the fair prices, what is the overall pool value after the exchange
function calcBuyAmountV3(
uint256 tokensMinted,
uint256 indexOut,
uint256 targetBalance,
uint256 collateralBalance,
uint256[] memory balances,
uint256[] memory fairPriceDecimals
) internal pure returns (uint256 tokensOut, uint256 newPoolValue) {
// If balances is longer than fair prices, that implies some tokens are worth 0 (such as refund tokens).
// They are inconsequential to the calculation here.
if (fairPriceDecimals.length > balances.length) revert AmmErrors.BalancePriceLengthMismatch();
// Also implies that even if indexOut is within the length of balances,
// if it is beyond the length of fairPrices, then the price of that
// token is 0. Buying 0-price tokens through the AMM should not be
// possible
if (indexOut >= fairPriceDecimals.length) revert AmmErrors.InvalidOutcomeIndex();
if (targetBalance == 0) revert AmmErrors.NoLiquidityAvailable();
// High level overview:
// 1. We exchange these tokens at a flat rate according to fairPrices. This ignores token balances.
// 2. We apply an AMM curve on the output tokens, relative to a target balance
uint256 tokensOutDecimal = 0;
uint256 newPoolValueDecimal = 0;
for (uint256 i = 0; i < fairPriceDecimals.length; i++) {
if (i == indexOut) continue;
// 1. flat exchange
uint256 inputTokensDecimal = tokensMinted * ONE_DECIMAL;
tokensOutDecimal +=
calcElementwiseFairAmount(inputTokensDecimal, fairPriceDecimals[i], fairPriceDecimals[indexOut]);
newPoolValueDecimal += (balances[i] + collateralBalance + tokensMinted) * fairPriceDecimals[i];
}
// 2. slippage for the out pool
uint256 flatnessDecimal = calculateFlatness(fairPriceDecimals[indexOut]);
tokensOutDecimal = applyOutputSlippage(
balances[indexOut] + collateralBalance, tokensOutDecimal / ONE_DECIMAL, targetBalance, flatnessDecimal
);
tokensOut = tokensOutDecimal / ONE_DECIMAL;
newPoolValueDecimal += (balances[indexOut] + collateralBalance - tokensOut) * fairPriceDecimals[indexOut];
newPoolValue = newPoolValueDecimal.ceilDiv(ONE_DECIMAL);
}
/// @dev Calculate the current prices of all tokens, only with spread, and
/// no slippage. This can be used on the frontend to compare the price
/// impact of trade size. This code is generic with respect to how many
/// outcomes have prices.
/// @param targetBalance the target balance of each outcome token. We assume
/// equal target balance is optimal, so it can be represented by a single
/// value rather than an array. All token balances should ideally equal this
/// value
/// @param collateralBalance Extra collateral available to mint more tokens
/// @param balances The current balances of each outcome token in the pool
/// @param fairPriceDecimals normalized prices for each outcome token
/// provided externally. Any missing trailing prices are assumed to be 0.
/// @return spontaneousPriceDecimals the modified prices of each token that
/// include the spread. Will not sum to ONE_DECIMAL.
function calcSpontaneousPricesV3(
uint256 targetBalance,
uint256 collateralBalance,
uint256[] memory balances,
uint256[] memory fairPriceDecimals
) internal pure returns (uint256[] memory spontaneousPriceDecimals) {
if (fairPriceDecimals.length > balances.length) revert AmmErrors.BalancePriceLengthMismatch();
if (targetBalance == 0) revert AmmErrors.NoLiquidityAvailable();
spontaneousPriceDecimals = new uint256[](fairPriceDecimals.length);
uint256 tokensInDecimal = ONE_DECIMAL;
for (uint256 indexOut = 0; indexOut < spontaneousPriceDecimals.length; indexOut++) {
// Calculate the spontaneous price for each outcome
// Can be calculated by exchanging ONE_DECIMAL tokens at the
// spontaneous price to get number of tokens out. Then the
// reciprocal is the price
uint256 balanceOut = balances[indexOut] + collateralBalance;
uint256 tokensOutDecimal = 0;
for (uint256 indexIn = 0; indexIn < fairPriceDecimals.length; indexIn++) {
if (indexOut == indexIn) continue;
// 1. flat exchange
tokensOutDecimal +=
calcElementwiseFairAmount(tokensInDecimal, fairPriceDecimals[indexIn], fairPriceDecimals[indexOut]);
}
// 2. spread for the out pool
uint256 flatnessDecimal = calculateFlatness(fairPriceDecimals[indexOut]);
tokensOutDecimal = applyOutputSpread(balanceOut, tokensOutDecimal, targetBalance, flatnessDecimal);
// To get the price, need to consider total tokens acquired during a purchase.
// Typically tokens are split among all outcomes, and the unwanted
// ones are exchanged for tokensOut. The total at the end of output
// tokens also include the tokensIn amount from the split
uint256 tokensBoughtDecimal = tokensOutDecimal + tokensInDecimal;
spontaneousPriceDecimals[indexOut] = (tokensInDecimal * ONE_DECIMAL) / tokensBoughtDecimal;
}
}
/// @dev describes operations to be done with respect to parent funding in
/// order to maintain the right amount of reserves locally vs in the parent
struct ParentOperations {
uint256 collateralToRequestFromParent;
uint256 collateralToReturnToParent;
uint256 sharesToBurnOfParent;
}
struct TargetContext {
/// @dev target the target balance used by all AMM calculations
uint256 target;
/// @dev all collateral available to be used to mint tokens, including that from the parent
uint256 globalReserves;
uint256[] balances;
}
/// @dev Return the index into the balance array where the refund outcome is.
/// Documents the assumption in one place.
function getRefundIndex(uint256[] memory outcomeArray) internal pure returns (uint256 refundIndex) {
refundIndex = outcomeArray.length - 1;
}
function getRefundIndex(TargetContext memory targetContext) internal pure returns (uint256) {
return getRefundIndex(targetContext.balances);
}
struct BuyContext {
uint256 investmentMinusFees;
uint256 tokensExchanged;
uint256 newPoolValue;
uint256 refund;
}
/// @dev Calculate how the state of the Amm Pool should change as a result
/// of a buy order. This algorithm assumes a few more things than others in
/// this file:
/// - There is a parent pool from which we can request collateral, or return
/// any excess
/// - Besides buying a particular priced outcome, we are also taking care of
/// a mutually exclusive refund outcome
/// - The refund outcome is assumed to be the last index in the balances array
/// @param indexOut the index of the bought token
/// @param targetContext the current state of the pool - token balances,
/// reserves, and value target. This is modified in place to reflect the
/// state after the fact
/// @param buyContext the information from the buy order - how much was paid, and how much was received
/// @param parentShares how many parent shares exist (assumed that ALL shares are parent shares)
/// @return outcomeTokensBought the total amount of tokens the buyer should receive
/// @return tokensToMint how many tokens should be minted across all outcomes to fulfil the order
/// @return parentOps requests and returns of collateral to a parent pool
function calcMarketPoolChanges(
uint256 indexOut,
uint256 parentShares,
TargetContext memory targetContext,
BuyContext memory buyContext
) internal pure returns (uint256 outcomeTokensBought, uint256 tokensToMint, ParentOperations memory parentOps) {
parentOps = ParentOperations(0, 0, 0);
uint256 investmentMinusFees = buyContext.investmentMinusFees;
// Last index is assumed to be the refund outcome
uint256 refundIndex = getRefundIndex(targetContext);
{
outcomeTokensBought = buyContext.tokensExchanged + investmentMinusFees;
uint256 refundTokensToMint = buyContext.refund.subClamp(targetContext.balances[refundIndex]);
uint256 outcomeTokensToMint = outcomeTokensBought.subClamp(targetContext.balances[indexOut]);
tokensToMint = Math.max(refundTokensToMint, outcomeTokensToMint);
}
// check if we don't have enough tokens, or too many
if (tokensToMint >= investmentMinusFees) {
unchecked {
parentOps.collateralToRequestFromParent = tokensToMint - investmentMinusFees;
}
} else {
// In this case all parent funding is tied up in tokens. The
// leftover collateral from the buyer's investment is distributed
// back to the parent. Any shares owned by other accounts (due to
// removing liquidity in the form of child chares), do not have a
// claim on any collateral, only tokens. This is assymetric on
// purpose.
// - Less complex, less gas cost
// - Parent pool is main funder of collateral. Other accounts can
// remove liquidity in the form of risk (pure tokens) if they want it.
// parent is eligible to get all of leftover collateral
uint256 investmentLeftOver;
unchecked {
investmentLeftOver = investmentMinusFees - tokensToMint;
}
// if any individual funders removed liquidity in terms of child
// shares, they should have immediately been ejected and given
// tokens directly. No individual funder shares should be lingering
assert(parentShares > 0);
uint256 tokenAndLocalReservesValue = (buyContext.newPoolValue - targetContext.globalReserves);
parentOps.collateralToReturnToParent = investmentLeftOver;
// number of shares to return depends on proportion of the collateral we are returning to value in market
parentOps.sharesToBurnOfParent = (investmentLeftOver * parentShares) / tokenAndLocalReservesValue;
}
// Update TargetContext so it reflects the new state of the market
targetContext.globalReserves = targetContext.globalReserves + investmentMinusFees - tokensToMint;
for (uint256 i = 0; i < targetContext.balances.length; i++) {
targetContext.balances[i] += tokensToMint;
}
targetContext.balances[indexOut] -= outcomeTokensBought;
targetContext.balances[refundIndex] -= buyContext.refund;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import { ClampedMath } from "../Math.sol";
import { FundingErrors } from "./FundingErrors.sol";
library FundingMath {
using ClampedMath for uint256;
using Math for uint256;
uint256 internal constant SHARE_PRECISION_DECIMALS = 4;
uint256 internal constant SHARE_PRECISION_OFFSET = 10 ** SHARE_PRECISION_DECIMALS;
/// @dev We always try to keep the pools balanced. There are never any
/// "sendBackAmounts" like in a typical constant product AMM where the
/// balances need to be maintained to determine the prices. We want to
/// use all the available collateral for liquidity no matter what the
/// probabilities of the outcomes are.
/// @param collateralAdded how much collateral the funder is adding to the pool
/// @param totalShares the current number of liquidity pool shares in circulation
/// @param poolValue total sum of value of all tokens
/// @return sharesMinted how many liquidity pool shares should be minted
function calcFunding(uint256 collateralAdded, uint256 totalShares, uint256 poolValue)
internal
pure
returns (uint256 sharesMinted)
{
// To prevent inflation attack. See articles and reference implementation:
// https://mixbytes.io/blog/overview-of-the-inflation-attack
// https://docs.openzeppelin.com/contracts/4.x/erc4626#defending_with_a_virtual_offset
// https://github.com/boringcrypto/YieldBox/blob/master/contracts/YieldBoxRebase.sol#L24-L29
poolValue++;
totalShares += SHARE_PRECISION_OFFSET;
assert(totalShares > 0);
// mint LP tokens proportional to how much value the new investment
// brings to the pool
sharesMinted = (collateralAdded * totalShares).ceilDiv(poolValue);
}
/// @dev Calculate how much of an asset in the liquidity pool to return to a funder.
/// @param sharesToBurn how many liquidity pool shares a funder wants to burn
/// @param totalShares the current number of liquidity pool shares in circulation
/// @param balance number of an asset in the pool
/// @return sendAmount how many asset tokens to give back to funder
function calcReturnAmount(uint256 sharesToBurn, uint256 totalShares, uint256 balance)
internal
pure
returns (uint256 sendAmount)
{
if (sharesToBurn > totalShares) revert FundingErrors.InvalidBurnAmount();
if (sharesToBurn == 0) return sendAmount;
sendAmount = (balance * sharesToBurn) / totalShares;
}
/// @dev Calculate how much of the assets in the liquidity pool to return to a funder.
/// @param sharesToBurn how many liquidity pool shares a funder wants to burn
/// @param totalShares the current number of liquidity pool shares in circulation
/// @param balances number of each asset in the pool
/// @return sendAmounts how many asset tokens to give back to funder
function calcReturnAmounts(uint256 sharesToBurn, uint256 totalShares, uint256[] memory balances)
internal
pure
returns (uint256[] memory sendAmounts)
{
if (sharesToBurn > totalShares) revert FundingErrors.InvalidBurnAmount();
sendAmounts = new uint256[](balances.length);
if (sharesToBurn == 0) return sendAmounts;
for (uint256 i = 0; i < balances.length; i++) {
sendAmounts[i] = (balances[i] * sharesToBurn) / totalShares;
}
}
/// @dev Calculate how much to reduce the cost basis due to shares being burnt
/// @param funderShares how many liquidity pool shares a funder currently owns
/// @param sharesToBurn how many liquidity pool shares a funder currently owns
/// @param funderCostBasis how much collateral was spent acquiring the funder's liquidity pool shares
/// @return costBasisReduction the amount by which to reduce the costbasis for the funder
function calcCostBasisReduction(uint256 funderShares, uint256 sharesToBurn, uint256 funderCostBasis)
internal
pure
returns (uint256 costBasisReduction)
{
if (sharesToBurn > funderShares) revert FundingErrors.InvalidBurnAmount();
costBasisReduction = funderShares == 0 ? 0 : (funderCostBasis * sharesToBurn) / funderShares;
}
/// @dev Calculate how many shares to burn for an asset, so that how many
/// parent shares are removed are not a larger proportion of funder's
/// shares, than the proportion of the asset value among other assets.
///
/// i.e.
/// ((funderSharesRemovedAsAsset + sharesBurnt) / funderTotalShares)
/// <=
/// (assetValue / totalValue)
///
/// @param funderTotalShares Total parent shares owned and removed by funder
/// @param sharesToBurn How many funder shares we're trying to burn
/// @param funderSharesRemovedAsAsset quantity of shares already removed as the asset
/// @param assetValue current value of the asset
/// @param totalValue the total value to compare the asset value to. The
/// ratio of asset value to this total is what sharesBurnt should not exceed
/// @return sharesBurnt quantity of shares that can be burnt given the above restrictions
function calcMaxParentSharesToBurnForAsset(
uint256 funderTotalShares,
uint256 sharesToBurn,
uint256 funderSharesRemovedAsAsset,
uint256 assetValue,
uint256 totalValue
) internal pure returns (uint256 sharesBurnt) {
uint256 maxShares = ((funderTotalShares * assetValue).ceilDiv(totalValue)).subClamp(funderSharesRemovedAsAsset);
sharesBurnt = Math.min(sharesToBurn, maxShares);
if (sharesBurnt > 0) {
// This is a re-arrangement of the inequality given in the
// description. It only applies when we are trying to give out some
// shares. If sharesBurnt is 0, that means we've already exceeded
// how many shares we can safely burn, so the inequality is
// violated.
// The -1 is due to the rounding up in ceilDiv above, used to
// prevent never being able to burn the last remaining share
assert(((funderSharesRemovedAsAsset + sharesBurnt - 1) * totalValue) < (assetValue * funderTotalShares));
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface AmmErrors {
error InvalidOutcomeIndex();
error NoLiquidityAvailable();
error BalancePriceLengthMismatch();
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface FundingErrors {
error InvalidFundingAmount();
error InvalidBurnAmount();
error InvalidReceiverAddress();
error PoolValueZero();
/// @dev Fee is is or exceeds 100%
error InvalidFee();
/// @dev Trying to retain fees that exceed the current reserves
error FeesExceedReserves();
/// @dev Trying to unlock more fees than currently collected
error FeesExceedCollected();
/// @dev Funding is so large, that it may lead to overflow errors in future
/// actions
error ExcessiveFunding();
/// @dev Collateral ERC20 decimals exceed 18, leading to potential overflows
error ExcessiveCollateralDecimals();
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
/// @dev Functions to deal with 16bit prices packed into `bytes`.
/// In prediction markets, prices are within the range [0-1]. As such, arbitrary
/// magnitude and precision are not necessary. By restricting prices to be fixed
/// point integers between 0 and 1e4, we get:
/// - Prices fit in 16 bits
/// - Can be easily renormalized to 1e18 via a multiplier
///
/// The 16bit prices are packed back to back and encoded in big-endian format.
///
/// Some notes:
///
/// Packing/unpacking is done manually and not via solidity's uint16[].
/// uint16[] arrays are still encoded with all the padding. Additionally,
/// working directly with uint16 data types is less efficient than uint256, due
/// to bit shifting and masking that is implicitly done
library PackedPrices {
using Math for uint256;
/// @dev a divisor that fits in 16 bits, and easily divides into 1e18
uint256 internal constant DIVISOR = 1e4;
/// @dev divisor for majority of decimal calculations
uint256 internal constant ONE_DECIMAL = 1e18;
/// @dev We store packed prices in 16 bits with a divisor of 1e4. AMM math
/// relies on prices having divisor of 1e18. We can go directly from one to
/// the other by multiplying by 1e14.
uint256 internal constant DECIMAL_CONVERSION_FACTOR = 1e14;
/// @dev How many bits to shift to convert between big-endian uint16 and uint256
uint256 internal constant SHIFT_BITS = 30 * 8;
/// @dev Given a packed price byte array, unpack into a decimal price array with 1e18 divisor
/// @param packedPrices packed byte array
/// @return priceDecimals unpacked price array of prices normalized to 1e18
function toPriceDecimals(bytes memory packedPrices) internal pure returns (uint256[] memory priceDecimals) {
unchecked {
uint256 length = packedPrices.length / 2;
priceDecimals = new uint256[](length);
for (uint256 i; i < length; i++) {
uint256 chunk;
uint256 offset = 32 + i * 2;
assembly ("memory-safe") {
chunk := mload(add(packedPrices, offset))
}
priceDecimals[i] = (chunk >> SHIFT_BITS) * DECIMAL_CONVERSION_FACTOR;
}
}
}
/// @dev Given a packed price byte array in storage, unpack into a decimal price array with 1e18 divisor
/// @param packedPrices packed byte array storage pointer
/// @return priceDecimals unpacked price array of prices normalized to 1e18
function toPriceDecimalsFromStorage(bytes storage packedPrices) internal pure returns (uint256[] memory) {
// Much easier to copy the byte array into memory first, and then
// perform the conversion from memory array, than doing it directly from
// storage.
// This is because the storage load instruction `SLOAD` costs 200 gas,
// while the memory load instruction `MLOAD` costs only 3. The
// drastically simpler code that loads each integer one at a time would
// be extremely costly with SLOAD, and would require a different
// algorithm that amounts to copying into memory first to minimize SLOAD
// instructions.
return toPriceDecimals(packedPrices);
}
/// @dev Given an array of integers, packs them into a byte array of 16bit values.
/// Integers are taken as-is, with no re-normalization.
/// @param prices array of integers less than or equal to type(uint16).max . Otherwise truncation will occur
/// @param divisor what to divide prices by before packing
/// @return packedPrices packed byte array
function toPackedPrices(uint256[] memory prices, uint256 divisor)
internal
pure
returns (bytes memory packedPrices)
{
unchecked {
uint256 length = prices.length;
// set the size of bytes array
packedPrices = new bytes(length * 2);
for (uint256 i; i < length; i++) {
uint256 adjustedPrice = prices[i] / divisor;
assert(adjustedPrice <= type(uint16).max);
uint256 chunk = adjustedPrice << SHIFT_BITS;
uint256 offset = 32 + i * 2;
assembly {
mstore(add(packedPrices, offset), chunk)
}
}
}
}
/// @dev Sums the values in the packed price byte array
/// @param packedPrices the byte array that encodes the packed prices
/// @return result the sum of the decoded prices
function sum(bytes memory packedPrices) internal pure returns (uint256 result) {
unchecked {
uint256 length = packedPrices.length / 2;
for (uint256 i; i < length; i++) {
uint256 chunk;
uint256 offset = 32 + i * 2;
assembly ("memory-safe") {
chunk := mload(add(packedPrices, offset))
}
result += chunk >> SHIFT_BITS;
}
}
}
function arrayLength(bytes memory packedPrices) internal pure returns (uint256) {
return packedPrices.length / 2;
}
function valueAtIndex(bytes memory packedPrices, uint256 index) internal pure returns (uint256) {
uint256 chunk;
uint256 offset = 32 + index * 2;
assembly ("memory-safe") {
chunk := mload(add(packedPrices, offset))
}
return (chunk >> SHIFT_BITS);
}
// TODO: potentially optimize reading directly from storage
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
type QuestionID is bytes32;
type ConditionID is bytes32;
type CollectionID is bytes32;
library CTHelpers {
/// @dev Constructs a condition ID from an oracle, a question ID, and the
/// outcome slot count for the question.
/// @param oracle The account assigned to report the result for the prepared condition.
/// @param questionId An identifier for the question to be answered by the oracle.
/// @param outcomeSlotCount The number of outcome slots which should be used
/// for this condition. Must not exceed 256.
function getConditionId(address oracle, QuestionID questionId, uint256 outcomeSlotCount)
internal
pure
returns (ConditionID)
{
assert(outcomeSlotCount < 257); // `<` uses less gas than `<=`
return ConditionID.wrap(keccak256(abi.encodePacked(oracle, questionId, outcomeSlotCount)));
}
/// @dev Constructs an outcome collection ID
/// @param conditionId Condition ID of the outcome collection
/// @param index outcome index
function getCollectionId(ConditionID conditionId, uint256 index) internal pure returns (CollectionID) {
return CollectionID.wrap(keccak256(abi.encodePacked(conditionId, index)));
}
/// @dev Constructs a position ID from a collateral token and an outcome
/// collection. These IDs are used as the ERC-1155 ID for this contract.
/// @param collateralToken Collateral token which backs the position.
/// @param collectionId ID of the outcome collection associated with this position.
function getPositionId(IERC20 collateralToken, CollectionID collectionId) internal pure returns (uint256) {
return uint256(keccak256(abi.encodePacked(collateralToken, collectionId)));
}
/// @dev Constructs all position ID in a condition, for a collateral token.
/// These IDs are used as the ERC-1155 ID for the ConditionalTokens contract.
/// @param collateralToken Collateral token which backs the position.
/// @param conditionId ID of the condition associated with all positions
/// @param outcomeSlotCount number of outcomes in the condition
function getPositionIds(IERC20 collateralToken, ConditionID conditionId, uint256 outcomeSlotCount)
internal
pure
returns (uint256[] memory positionIds)
{
positionIds = new uint256[](outcomeSlotCount);
for (uint256 i = 0; i < outcomeSlotCount; i++) {
positionIds[i] = getPositionId(collateralToken, getCollectionId(conditionId, i));
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
return _paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library MathUpgradeable {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @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 up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (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; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 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.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
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 (rounding == Rounding.Up && 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 down.
*
* 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* 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 + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* 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 10, 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 + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165Upgradeable {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC20Upgradeable } from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import { FundingErrors } from "./FundingErrors.sol";
interface FundingPoolEvents {
/// @notice Collateral is added to the liquidity pool
/// @param sender the account that initiated and supplied the collateral for the funding
/// @param funder the account that receives the liquidity pool shares
/// @param collateralAdded the quantity of collateral supplied to the pool
/// @param sharesMinted the quantity of liquidity pool shares created as sa result of the funding
event FundingAdded(address indexed sender, address indexed funder, uint256 collateralAdded, uint256 sharesMinted);
/// @notice Funding is removed as a mix of tokens and collateral
/// @param funder the owner of liquidity pool shares
/// @param collateralRemoved the quantity of collateral removed from the pool proportional to funder's shares
/// @param tokensRemoved the quantity of tokens removed from the pool proportional to funder's shares. Can be empty
/// @param sharesBurnt the quantity of liquidity pool shares burnt
event FundingRemoved(
address indexed funder, uint256 collateralRemoved, uint256[] tokensRemoved, uint256 sharesBurnt
);
/// @notice Funding is removed as a specific token, referred to by an id
/// @param funder the owner of liquidity pool shares
/// @param tokenId an id that identifies a single asset token in the pool. Up to the pool to decide the meaning of the id
/// @param tokensRemoved the quantity of a token removed from the pool
/// @param sharesBurnt the quantity of liquidity pool shares burnt
event FundingRemovedAsToken(
address indexed funder, uint256 indexed tokenId, uint256 tokensRemoved, uint256 sharesBurnt
);
/// @notice Some portion of collateral was withdrawn for fee purposes
event FeesWithdrawn(address indexed funder, uint256 collateralRemovedFromFees);
/// @notice Some portion of collateral was retained for fee purposes
event FeesRetained(uint256 collateralAddedToFees);
}
/// @dev A funding pool deals with 3 different assets:
/// - collateral with which to make investments (ERC20 tokens of general usage, e.g. USDT, USDC, DAI, etc.)
/// - shares which represent the stake in the fund (ERC20 tokens minted and burned by the funding pool)
/// - tokens that are the actual investments (e.g. ERC1155 conditional tokens)
interface IFundingPoolV1 is IERC20Upgradeable, FundingErrors, FundingPoolEvents {
/// @notice Funds the market with collateral from the sender
/// @param collateralAdded Amount of funds from the sender to transfer to the market
function addFunding(uint256 collateralAdded) external returns (uint256 sharesMinted);
/// @notice Funds the market on behalf of receiver.
/// @param receiver Account that receives LP tokens.
/// @param collateralAdded Amount of funds from the sender to transfer to the market
function addFundingFor(address receiver, uint256 collateralAdded) external returns (uint256 sharesMinted);
/// @notice Withdraws the fees from a particular liquidity provider.
/// @param funder Account address to withdraw its available fees.
function withdrawFees(address funder) external returns (uint256 collateralRemovedFromFees);
/// @notice Returns the amount of fee in collateral to be withdrawn by the liquidity providers.
/// @param account Account address to check for fees available.
function feesWithdrawableBy(address account) external view returns (uint256 collateralFees);
/// @notice How much collateral is available that is not set aside for fees
function reserves() external view returns (uint256 collateral);
/// @notice Returns the current collected fees on this market.
function collectedFees() external view returns (uint256 collateralFees);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface UpdateFairPricesEvents {
event MarketPricesUpdated(uint256[] fairPriceDecimals);
event MarketMinPriceUpdated(uint128 minPriceDecimal);
}
interface IUpdateFairPrices is UpdateFairPricesEvents {
function updateFairPrices(uint256[] calldata fairPriceDecimals) external;
function updateMinPrice(uint128 minPriceDecimal) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/
interface IERC1155Upgradeable is IERC165Upgradeable {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
* transfers.
*/
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
/**
* @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
* `approved`.
*/
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
/**
* @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
*
* If an {URI} event was emitted for `id`, the standard
* https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
* returned by {IERC1155MetadataURI-uri}.
*/
event URI(string value, uint256 indexed id);
/**
* @dev Returns the amount of tokens of token type `id` owned by `account`.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) external view returns (uint256);
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
/**
* @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
*
* Emits an {ApprovalForAll} event.
*
* Requirements:
*
* - `operator` cannot be the caller.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address account, address operator) external view returns (bool);
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface ConditionalTokensErrors {
error ConditionAlreadyPrepared();
error PayoutAlreadyReported();
error PayoutsAreAllZero();
error InvalidOutcomeSlotCountsArray();
error InvalidPayoutArray();
error ResultNotReceivedYet();
error InvalidIndex();
error NoPositionsToRedeem();
error ConditionNotFound();
error InvalidAmount();
error InvalidOutcomeSlotsAmount();
error InvalidQuantities();
error InvalidPrices();
error InvalidConditionOracle(address conditionOracle);
error MustBeCalledByOracle();
error InvalidHaltTime();
/// @dev using unapproved ERC20 token with protocol
error InvalidERC20();
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
import "./IERC20Upgradeable.sol";
import "./extensions/IERC20MetadataUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* The default value of {decimals} is 18. To select a different value for
* {decimals} you should overload it.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the value {ERC20} uses, unless this function is
* overridden;
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens have been burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[45] private __gap;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IFundingPoolV1 } from "./IFundingPoolV1.sol";
/// @dev An extension to IFundingPoolV1 that adds more methods to inspect cost basis,
interface IFundingPoolV1_1 is IFundingPoolV1 {
/// @dev How much collateral was spent by a funder to obtain their current shares
function getFunderCostBasis(address funder) external returns (uint256);
/// @dev How much collateral was spent by all funders to obtain their current shares
function getTotalFunderCostBasis() external returns (uint256);
/// @dev Current estimated value in collateral of the entire pool
function getPoolValue() external returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC165Upgradeable } from "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol";
interface ChildFundingPoolErrors {
error NotAParentPool(address parentPool);
}
interface ChildFundingPoolEvents {
event ParentPoolAdded(address indexed parentPool);
}
/// @dev Interface for a funding pool that can be added as a child to a Parent Funding pool
interface IChildFundingPoolV1 is IERC165Upgradeable, ChildFundingPoolEvents, ChildFundingPoolErrors {
function getParentPool() external view returns (address);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import { IERC165Upgradeable } from "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol";
import { ContextUpgradeable } from "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
interface ParentFundingPoolErrors {
/// @dev Occurs when a child pool does not support the necessary interfaces
error NotAChildPool(address childPool);
/// @dev Occurs when a child pool is not approved to perform the operation
error ChildPoolNotApproved(address childPool);
/// @dev Occurs when batch operations have mismatching array lengths
error InvalidBatchLength();
}
interface ParentFundingPoolEvents {
/// @dev A child pool approval was added or removed
event ChildPoolApproval(address indexed childPool, uint256 approved);
/// @dev Limit of how much can be requested has changed
event RequestLimitChanged(uint256 limit);
/// @dev A child pool has requested some funds, and the parent gives it. The
/// value locked into the child is exactly equal to the collateralGiven
event FundingGiven(address indexed childPool, uint256 collateralGiven);
/// @dev A child pool has returned some funding, unlocking some value
/// @param childPool the child pool that borrowed the funds
/// @param collateralReturned quantity of collateral given back to the pool
/// @param valueUnlocked due to profit/loss, collateral returned may not
/// equal in value to what was originally given. valueUnlocked corresponds
/// to the portion of original collateral that is returned
event FundingReturned(address indexed childPool, uint256 collateralReturned, uint256 valueUnlocked);
}
/// @dev Interface for a FundingPool that allows child FundingPools to request/return funds
interface IParentFundingPoolV1 is IERC165Upgradeable, ParentFundingPoolEvents, ParentFundingPoolErrors {
/// @dev childPool should support IFundingPoolV1 interface
function setApprovalForChild(address childPool, uint256 approval) external;
/// @dev Called by an approved child pool, to request collateral
/// NOTE: assumes msg.sender supports IFundingPool that is approved
/// @param collateralRequested how much collateral is requested by the childPool
/// @return collateralAdded Actual amount given (which may be lower than collateralRequested)
/// @return sharesMinted How many child shares were given due to the funding
function requestFunding(uint256 collateralRequested)
external
returns (uint256 collateralAdded, uint256 sharesMinted);
/// @dev Notify parent after voluntarily returning back some collateral, and burning corresponding shares
/// @param collateralReturned how much collateral funding was transferred from child to parent
/// @param sharesBurnt how many child shares were burnt as a result
function fundingReturned(uint256 collateralReturned, uint256 sharesBurnt) external;
/// @dev Notify parent after voluntarily returning back some fees
/// @param fees how much fees (in collateral) was transferred from child to parent
function feesReturned(uint256 fees) external;
/// @dev What is the maximum amount of collateral a child can request from the parent
function getApprovalForChild(address childPool) external view returns (uint256 approval);
/// @dev See how much funding is available for a particular child pool.
/// Takes into account how much has already been consumed from the approval,
/// and how much collateral is available in the pool.
/// @param childPool address of the childPool
/// @return availableFunding how much collateral can be requested, that takes into account any gains or losses
/// @return targetFunding The target funding amount that can be requested, without gains or losses
function getAvailableFunding(address childPool)
external
view
returns (uint256 availableFunding, uint256 targetFunding);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
pragma solidity ^0.8.0;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
* unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
* array of EnumerableSet.
* ====
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastValue;
// Update the index for the moved value
set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
/// @solidity memory-safe-assembly
assembly {
result := store
}
return result;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
/*
██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██╗
██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
██████╔╝██████╔╝██████╔╝██╔████╔██║███████║ ██║ ███████║
██╔═══╝ ██╔══██╗██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
██║ ██║ ██║██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
██╗ ██╗██████╗ ██████╗ ██████╗ ██╗ ██╗ ██╗ █████╗
██║ ██║██╔══██╗██╔════╝ ██╔═████╗╚██╗██╔╝███║██╔══██╗
██║ ██║██║ ██║███████╗ ██║██╔██║ ╚███╔╝ ╚██║╚█████╔╝
██║ ██║██║ ██║██╔═══██╗████╔╝██║ ██╔██╗ ██║██╔══██╗
╚██████╔╝██████╔╝╚██████╔╝╚██████╔╝██╔╝ ██╗ ██║╚█████╔╝
╚═════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚════╝
*/
import "./ud60x18/Casting.sol";
import "./ud60x18/Constants.sol";
import "./ud60x18/Conversions.sol";
import "./ud60x18/Errors.sol";
import "./ud60x18/Helpers.sol";
import "./ud60x18/Math.sol";
import "./ud60x18/ValueType.sol";
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20Upgradeable {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC20Upgradeable.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
/**
* @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);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Errors.sol" as CastingErrors;
import { MAX_UINT128, MAX_UINT40 } from "../Common.sol";
import { uMAX_SD1x18 } from "../sd1x18/Constants.sol";
import { SD1x18 } from "../sd1x18/ValueType.sol";
import { uMAX_SD59x18 } from "../sd59x18/Constants.sol";
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { uMAX_UD2x18 } from "../ud2x18/Constants.sol";
import { UD2x18 } from "../ud2x18/ValueType.sol";
import { UD60x18 } from "./ValueType.sol";
/// @notice Casts a UD60x18 number into SD1x18.
/// @dev Requirements:
/// - x must be less than or equal to `uMAX_SD1x18`.
function intoSD1x18(UD60x18 x) pure returns (SD1x18 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > uint256(int256(uMAX_SD1x18))) {
revert CastingErrors.PRBMath_UD60x18_IntoSD1x18_Overflow(x);
}
result = SD1x18.wrap(int64(uint64(xUint)));
}
/// @notice Casts a UD60x18 number into UD2x18.
/// @dev Requirements:
/// - x must be less than or equal to `uMAX_UD2x18`.
function intoUD2x18(UD60x18 x) pure returns (UD2x18 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > uMAX_UD2x18) {
revert CastingErrors.PRBMath_UD60x18_IntoUD2x18_Overflow(x);
}
result = UD2x18.wrap(uint64(xUint));
}
/// @notice Casts a UD60x18 number into SD59x18.
/// @dev Requirements:
/// - x must be less than or equal to `uMAX_SD59x18`.
function intoSD59x18(UD60x18 x) pure returns (SD59x18 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > uint256(uMAX_SD59x18)) {
revert CastingErrors.PRBMath_UD60x18_IntoSD59x18_Overflow(x);
}
result = SD59x18.wrap(int256(xUint));
}
/// @notice Casts a UD60x18 number into uint128.
/// @dev This is basically an alias for {unwrap}.
function intoUint256(UD60x18 x) pure returns (uint256 result) {
result = UD60x18.unwrap(x);
}
/// @notice Casts a UD60x18 number into uint128.
/// @dev Requirements:
/// - x must be less than or equal to `MAX_UINT128`.
function intoUint128(UD60x18 x) pure returns (uint128 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > MAX_UINT128) {
revert CastingErrors.PRBMath_UD60x18_IntoUint128_Overflow(x);
}
result = uint128(xUint);
}
/// @notice Casts a UD60x18 number into uint40.
/// @dev Requirements:
/// - x must be less than or equal to `MAX_UINT40`.
function intoUint40(UD60x18 x) pure returns (uint40 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > MAX_UINT40) {
revert CastingErrors.PRBMath_UD60x18_IntoUint40_Overflow(x);
}
result = uint40(xUint);
}
/// @notice Alias for {wrap}.
function ud(uint256 x) pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
/// @notice Alias for {wrap}.
function ud60x18(uint256 x) pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
/// @notice Unwraps a UD60x18 number into uint256.
function unwrap(UD60x18 x) pure returns (uint256 result) {
result = UD60x18.unwrap(x);
}
/// @notice Wraps a uint256 number into the UD60x18 value type.
function wrap(uint256 x) pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD60x18 } from "./ValueType.sol";
// NOTICE: the "u" prefix stands for "unwrapped".
/// @dev Euler's number as a UD60x18 number.
UD60x18 constant E = UD60x18.wrap(2_718281828459045235);
/// @dev The maximum input permitted in {exp}.
uint256 constant uEXP_MAX_INPUT = 133_084258667509499440;
UD60x18 constant EXP_MAX_INPUT = UD60x18.wrap(uEXP_MAX_INPUT);
/// @dev The maximum input permitted in {exp2}.
uint256 constant uEXP2_MAX_INPUT = 192e18 - 1;
UD60x18 constant EXP2_MAX_INPUT = UD60x18.wrap(uEXP2_MAX_INPUT);
/// @dev Half the UNIT number.
uint256 constant uHALF_UNIT = 0.5e18;
UD60x18 constant HALF_UNIT = UD60x18.wrap(uHALF_UNIT);
/// @dev $log_2(10)$ as a UD60x18 number.
uint256 constant uLOG2_10 = 3_321928094887362347;
UD60x18 constant LOG2_10 = UD60x18.wrap(uLOG2_10);
/// @dev $log_2(e)$ as a UD60x18 number.
uint256 constant uLOG2_E = 1_442695040888963407;
UD60x18 constant LOG2_E = UD60x18.wrap(uLOG2_E);
/// @dev The maximum value a UD60x18 number can have.
uint256 constant uMAX_UD60x18 = 115792089237316195423570985008687907853269984665640564039457_584007913129639935;
UD60x18 constant MAX_UD60x18 = UD60x18.wrap(uMAX_UD60x18);
/// @dev The maximum whole value a UD60x18 number can have.
uint256 constant uMAX_WHOLE_UD60x18 = 115792089237316195423570985008687907853269984665640564039457_000000000000000000;
UD60x18 constant MAX_WHOLE_UD60x18 = UD60x18.wrap(uMAX_WHOLE_UD60x18);
/// @dev PI as a UD60x18 number.
UD60x18 constant PI = UD60x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of UD60x18.
uint256 constant uUNIT = 1e18;
UD60x18 constant UNIT = UD60x18.wrap(uUNIT);
/// @dev The unit number squared.
uint256 constant uUNIT_SQUARED = 1e36;
UD60x18 constant UNIT_SQUARED = UD60x18.wrap(uUNIT_SQUARED);
/// @dev Zero as a UD60x18 number.
UD60x18 constant ZERO = UD60x18.wrap(0);
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { uMAX_UD60x18, uUNIT } from "./Constants.sol";
import { PRBMath_UD60x18_Convert_Overflow } from "./Errors.sol";
import { UD60x18 } from "./ValueType.sol";
/// @notice Converts a UD60x18 number to a simple integer by dividing it by `UNIT`.
/// @dev The result is rounded toward zero.
/// @param x The UD60x18 number to convert.
/// @return result The same number in basic integer form.
function convert(UD60x18 x) pure returns (uint256 result) {
result = UD60x18.unwrap(x) / uUNIT;
}
/// @notice Converts a simple integer to UD60x18 by multiplying it by `UNIT`.
///
/// @dev Requirements:
/// - x must be less than or equal to `MAX_UD60x18 / UNIT`.
///
/// @param x The basic integer to convert.
/// @param result The same number converted to UD60x18.
function convert(uint256 x) pure returns (UD60x18 result) {
if (x > uMAX_UD60x18 / uUNIT) {
revert PRBMath_UD60x18_Convert_Overflow(x);
}
unchecked {
result = UD60x18.wrap(x * uUNIT);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD60x18 } from "./ValueType.sol";
/// @notice Thrown when ceiling a number overflows UD60x18.
error PRBMath_UD60x18_Ceil_Overflow(UD60x18 x);
/// @notice Thrown when converting a basic integer to the fixed-point format overflows UD60x18.
error PRBMath_UD60x18_Convert_Overflow(uint256 x);
/// @notice Thrown when taking the natural exponent of a base greater than 133_084258667509499441.
error PRBMath_UD60x18_Exp_InputTooBig(UD60x18 x);
/// @notice Thrown when taking the binary exponent of a base greater than 192e18.
error PRBMath_UD60x18_Exp2_InputTooBig(UD60x18 x);
/// @notice Thrown when taking the geometric mean of two numbers and multiplying them overflows UD60x18.
error PRBMath_UD60x18_Gm_Overflow(UD60x18 x, UD60x18 y);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD1x18.
error PRBMath_UD60x18_IntoSD1x18_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD59x18.
error PRBMath_UD60x18_IntoSD59x18_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in UD2x18.
error PRBMath_UD60x18_IntoUD2x18_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint128.
error PRBMath_UD60x18_IntoUint128_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint40.
error PRBMath_UD60x18_IntoUint40_Overflow(UD60x18 x);
/// @notice Thrown when taking the logarithm of a number less than 1.
error PRBMath_UD60x18_Log_InputTooSmall(UD60x18 x);
/// @notice Thrown when calculating the square root overflows UD60x18.
error PRBMath_UD60x18_Sqrt_Overflow(UD60x18 x);
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { wrap } from "./Casting.sol";
import { UD60x18 } from "./ValueType.sol";
/// @notice Implements the checked addition operation (+) in the UD60x18 type.
function add(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() + y.unwrap());
}
/// @notice Implements the AND (&) bitwise operation in the UD60x18 type.
function and(UD60x18 x, uint256 bits) pure returns (UD60x18 result) {
result = wrap(x.unwrap() & bits);
}
/// @notice Implements the AND (&) bitwise operation in the UD60x18 type.
function and2(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() & y.unwrap());
}
/// @notice Implements the equal operation (==) in the UD60x18 type.
function eq(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() == y.unwrap();
}
/// @notice Implements the greater than operation (>) in the UD60x18 type.
function gt(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() > y.unwrap();
}
/// @notice Implements the greater than or equal to operation (>=) in the UD60x18 type.
function gte(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() >= y.unwrap();
}
/// @notice Implements a zero comparison check function in the UD60x18 type.
function isZero(UD60x18 x) pure returns (bool result) {
// This wouldn't work if x could be negative.
result = x.unwrap() == 0;
}
/// @notice Implements the left shift operation (<<) in the UD60x18 type.
function lshift(UD60x18 x, uint256 bits) pure returns (UD60x18 result) {
result = wrap(x.unwrap() << bits);
}
/// @notice Implements the lower than operation (<) in the UD60x18 type.
function lt(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() < y.unwrap();
}
/// @notice Implements the lower than or equal to operation (<=) in the UD60x18 type.
function lte(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() <= y.unwrap();
}
/// @notice Implements the checked modulo operation (%) in the UD60x18 type.
function mod(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() % y.unwrap());
}
/// @notice Implements the not equal operation (!=) in the UD60x18 type.
function neq(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() != y.unwrap();
}
/// @notice Implements the NOT (~) bitwise operation in the UD60x18 type.
function not(UD60x18 x) pure returns (UD60x18 result) {
result = wrap(~x.unwrap());
}
/// @notice Implements the OR (|) bitwise operation in the UD60x18 type.
function or(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() | y.unwrap());
}
/// @notice Implements the right shift operation (>>) in the UD60x18 type.
function rshift(UD60x18 x, uint256 bits) pure returns (UD60x18 result) {
result = wrap(x.unwrap() >> bits);
}
/// @notice Implements the checked subtraction operation (-) in the UD60x18 type.
function sub(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() - y.unwrap());
}
/// @notice Implements the unchecked addition operation (+) in the UD60x18 type.
function uncheckedAdd(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
unchecked {
result = wrap(x.unwrap() + y.unwrap());
}
}
/// @notice Implements the unchecked subtraction operation (-) in the UD60x18 type.
function uncheckedSub(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
unchecked {
result = wrap(x.unwrap() - y.unwrap());
}
}
/// @notice Implements the XOR (^) bitwise operation in the UD60x18 type.
function xor(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() ^ y.unwrap());
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as Errors;
import { wrap } from "./Casting.sol";
import {
uEXP_MAX_INPUT,
uEXP2_MAX_INPUT,
uHALF_UNIT,
uLOG2_10,
uLOG2_E,
uMAX_UD60x18,
uMAX_WHOLE_UD60x18,
UNIT,
uUNIT,
uUNIT_SQUARED,
ZERO
} from "./Constants.sol";
import { UD60x18 } from "./ValueType.sol";
/*//////////////////////////////////////////////////////////////////////////
MATHEMATICAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
/// @notice Calculates the arithmetic average of x and y using the following formula:
///
/// $$
/// avg(x, y) = (x & y) + ((xUint ^ yUint) / 2)
/// $$
///
/// In English, this is what this formula does:
///
/// 1. AND x and y.
/// 2. Calculate half of XOR x and y.
/// 3. Add the two results together.
///
/// This technique is known as SWAR, which stands for "SIMD within a register". You can read more about it here:
/// https://devblogs.microsoft.com/oldnewthing/20220207-00/?p=106223
///
/// @dev Notes:
/// - The result is rounded toward zero.
///
/// @param x The first operand as a UD60x18 number.
/// @param y The second operand as a UD60x18 number.
/// @return result The arithmetic average as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function avg(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
uint256 yUint = y.unwrap();
unchecked {
result = wrap((xUint & yUint) + ((xUint ^ yUint) >> 1));
}
}
/// @notice Yields the smallest whole number greater than or equal to x.
///
/// @dev This is optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional
/// counterparts. See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
///
/// Requirements:
/// - x must be less than or equal to `MAX_WHOLE_UD60x18`.
///
/// @param x The UD60x18 number to ceil.
/// @param result The smallest whole number greater than or equal to x, as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function ceil(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
if (xUint > uMAX_WHOLE_UD60x18) {
revert Errors.PRBMath_UD60x18_Ceil_Overflow(x);
}
assembly ("memory-safe") {
// Equivalent to `x % UNIT`.
let remainder := mod(x, uUNIT)
// Equivalent to `UNIT - remainder`.
let delta := sub(uUNIT, remainder)
// Equivalent to `x + remainder > 0 ? delta : 0`.
result := add(x, mul(delta, gt(remainder, 0)))
}
}
/// @notice Divides two UD60x18 numbers, returning a new UD60x18 number.
///
/// @dev Uses {Common.mulDiv} to enable overflow-safe multiplication and division.
///
/// Notes:
/// - Refer to the notes in {Common.mulDiv}.
///
/// Requirements:
/// - Refer to the requirements in {Common.mulDiv}.
///
/// @param x The numerator as a UD60x18 number.
/// @param y The denominator as a UD60x18 number.
/// @param result The quotient as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function div(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(Common.mulDiv(x.unwrap(), uUNIT, y.unwrap()));
}
/// @notice Calculates the natural exponent of x using the following formula:
///
/// $$
/// e^x = 2^{x * log_2{e}}
/// $$
///
/// @dev Requirements:
/// - x must be less than 133_084258667509499441.
///
/// @param x The exponent as a UD60x18 number.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function exp(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
// This check prevents values greater than 192e18 from being passed to {exp2}.
if (xUint > uEXP_MAX_INPUT) {
revert Errors.PRBMath_UD60x18_Exp_InputTooBig(x);
}
unchecked {
// Inline the fixed-point multiplication to save gas.
uint256 doubleUnitProduct = xUint * uLOG2_E;
result = exp2(wrap(doubleUnitProduct / uUNIT));
}
}
/// @notice Calculates the binary exponent of x using the binary fraction method.
///
/// @dev See https://ethereum.stackexchange.com/q/79903/24693
///
/// Requirements:
/// - x must be less than 192e18.
/// - The result must fit in UD60x18.
///
/// @param x The exponent as a UD60x18 number.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function exp2(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
// Numbers greater than or equal to 192e18 don't fit in the 192.64-bit format.
if (xUint > uEXP2_MAX_INPUT) {
revert Errors.PRBMath_UD60x18_Exp2_InputTooBig(x);
}
// Convert x to the 192.64-bit fixed-point format.
uint256 x_192x64 = (xUint << 64) / uUNIT;
// Pass x to the {Common.exp2} function, which uses the 192.64-bit fixed-point number representation.
result = wrap(Common.exp2(x_192x64));
}
/// @notice Yields the greatest whole number less than or equal to x.
/// @dev Optimized for fractional value inputs, because every whole value has (1e18 - 1) fractional counterparts.
/// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
/// @param x The UD60x18 number to floor.
/// @param result The greatest whole number less than or equal to x, as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function floor(UD60x18 x) pure returns (UD60x18 result) {
assembly ("memory-safe") {
// Equivalent to `x % UNIT`.
let remainder := mod(x, uUNIT)
// Equivalent to `x - remainder > 0 ? remainder : 0)`.
result := sub(x, mul(remainder, gt(remainder, 0)))
}
}
/// @notice Yields the excess beyond the floor of x using the odd function definition.
/// @dev See https://en.wikipedia.org/wiki/Fractional_part.
/// @param x The UD60x18 number to get the fractional part of.
/// @param result The fractional part of x as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function frac(UD60x18 x) pure returns (UD60x18 result) {
assembly ("memory-safe") {
result := mod(x, uUNIT)
}
}
/// @notice Calculates the geometric mean of x and y, i.e. $\sqrt{x * y}$, rounding down.
///
/// @dev Requirements:
/// - x * y must fit in UD60x18.
///
/// @param x The first operand as a UD60x18 number.
/// @param y The second operand as a UD60x18 number.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function gm(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
uint256 yUint = y.unwrap();
if (xUint == 0 || yUint == 0) {
return ZERO;
}
unchecked {
// Checking for overflow this way is faster than letting Solidity do it.
uint256 xyUint = xUint * yUint;
if (xyUint / xUint != yUint) {
revert Errors.PRBMath_UD60x18_Gm_Overflow(x, y);
}
// We don't need to multiply the result by `UNIT` here because the x*y product picked up a factor of `UNIT`
// during multiplication. See the comments in {Common.sqrt}.
result = wrap(Common.sqrt(xyUint));
}
}
/// @notice Calculates the inverse of x.
///
/// @dev Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - x must not be zero.
///
/// @param x The UD60x18 number for which to calculate the inverse.
/// @return result The inverse as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function inv(UD60x18 x) pure returns (UD60x18 result) {
unchecked {
result = wrap(uUNIT_SQUARED / x.unwrap());
}
}
/// @notice Calculates the natural logarithm of x using the following formula:
///
/// $$
/// ln{x} = log_2{x} / log_2{e}
/// $$
///
/// @dev Notes:
/// - Refer to the notes in {log2}.
/// - The precision isn't sufficiently fine-grained to return exactly `UNIT` when the input is `E`.
///
/// Requirements:
/// - Refer to the requirements in {log2}.
///
/// @param x The UD60x18 number for which to calculate the natural logarithm.
/// @return result The natural logarithm as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function ln(UD60x18 x) pure returns (UD60x18 result) {
unchecked {
// Inline the fixed-point multiplication to save gas. This is overflow-safe because the maximum value that
// {log2} can return is ~196_205294292027477728.
result = wrap(log2(x).unwrap() * uUNIT / uLOG2_E);
}
}
/// @notice Calculates the common logarithm of x using the following formula:
///
/// $$
/// log_{10}{x} = log_2{x} / log_2{10}
/// $$
///
/// However, if x is an exact power of ten, a hard coded value is returned.
///
/// @dev Notes:
/// - Refer to the notes in {log2}.
///
/// Requirements:
/// - Refer to the requirements in {log2}.
///
/// @param x The UD60x18 number for which to calculate the common logarithm.
/// @return result The common logarithm as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function log10(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
if (xUint < uUNIT) {
revert Errors.PRBMath_UD60x18_Log_InputTooSmall(x);
}
// Note that the `mul` in this assembly block is the standard multiplication operation, not {UD60x18.mul}.
// prettier-ignore
assembly ("memory-safe") {
switch x
case 1 { result := mul(uUNIT, sub(0, 18)) }
case 10 { result := mul(uUNIT, sub(1, 18)) }
case 100 { result := mul(uUNIT, sub(2, 18)) }
case 1000 { result := mul(uUNIT, sub(3, 18)) }
case 10000 { result := mul(uUNIT, sub(4, 18)) }
case 100000 { result := mul(uUNIT, sub(5, 18)) }
case 1000000 { result := mul(uUNIT, sub(6, 18)) }
case 10000000 { result := mul(uUNIT, sub(7, 18)) }
case 100000000 { result := mul(uUNIT, sub(8, 18)) }
case 1000000000 { result := mul(uUNIT, sub(9, 18)) }
case 10000000000 { result := mul(uUNIT, sub(10, 18)) }
case 100000000000 { result := mul(uUNIT, sub(11, 18)) }
case 1000000000000 { result := mul(uUNIT, sub(12, 18)) }
case 10000000000000 { result := mul(uUNIT, sub(13, 18)) }
case 100000000000000 { result := mul(uUNIT, sub(14, 18)) }
case 1000000000000000 { result := mul(uUNIT, sub(15, 18)) }
case 10000000000000000 { result := mul(uUNIT, sub(16, 18)) }
case 100000000000000000 { result := mul(uUNIT, sub(17, 18)) }
case 1000000000000000000 { result := 0 }
case 10000000000000000000 { result := uUNIT }
case 100000000000000000000 { result := mul(uUNIT, 2) }
case 1000000000000000000000 { result := mul(uUNIT, 3) }
case 10000000000000000000000 { result := mul(uUNIT, 4) }
case 100000000000000000000000 { result := mul(uUNIT, 5) }
case 1000000000000000000000000 { result := mul(uUNIT, 6) }
case 10000000000000000000000000 { result := mul(uUNIT, 7) }
case 100000000000000000000000000 { result := mul(uUNIT, 8) }
case 1000000000000000000000000000 { result := mul(uUNIT, 9) }
case 10000000000000000000000000000 { result := mul(uUNIT, 10) }
case 100000000000000000000000000000 { result := mul(uUNIT, 11) }
case 1000000000000000000000000000000 { result := mul(uUNIT, 12) }
case 10000000000000000000000000000000 { result := mul(uUNIT, 13) }
case 100000000000000000000000000000000 { result := mul(uUNIT, 14) }
case 1000000000000000000000000000000000 { result := mul(uUNIT, 15) }
case 10000000000000000000000000000000000 { result := mul(uUNIT, 16) }
case 100000000000000000000000000000000000 { result := mul(uUNIT, 17) }
case 1000000000000000000000000000000000000 { result := mul(uUNIT, 18) }
case 10000000000000000000000000000000000000 { result := mul(uUNIT, 19) }
case 100000000000000000000000000000000000000 { result := mul(uUNIT, 20) }
case 1000000000000000000000000000000000000000 { result := mul(uUNIT, 21) }
case 10000000000000000000000000000000000000000 { result := mul(uUNIT, 22) }
case 100000000000000000000000000000000000000000 { result := mul(uUNIT, 23) }
case 1000000000000000000000000000000000000000000 { result := mul(uUNIT, 24) }
case 10000000000000000000000000000000000000000000 { result := mul(uUNIT, 25) }
case 100000000000000000000000000000000000000000000 { result := mul(uUNIT, 26) }
case 1000000000000000000000000000000000000000000000 { result := mul(uUNIT, 27) }
case 10000000000000000000000000000000000000000000000 { result := mul(uUNIT, 28) }
case 100000000000000000000000000000000000000000000000 { result := mul(uUNIT, 29) }
case 1000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 30) }
case 10000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 31) }
case 100000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 32) }
case 1000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 33) }
case 10000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 34) }
case 100000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 35) }
case 1000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 36) }
case 10000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 37) }
case 100000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 38) }
case 1000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 39) }
case 10000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 40) }
case 100000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 41) }
case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 42) }
case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 43) }
case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 44) }
case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 45) }
case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 46) }
case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 47) }
case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 48) }
case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 49) }
case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 50) }
case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 51) }
case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 52) }
case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 53) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 54) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 55) }
case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 56) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 57) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 58) }
case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 59) }
default { result := uMAX_UD60x18 }
}
if (result.unwrap() == uMAX_UD60x18) {
unchecked {
// Inline the fixed-point division to save gas.
result = wrap(log2(x).unwrap() * uUNIT / uLOG2_10);
}
}
}
/// @notice Calculates the binary logarithm of x using the iterative approximation algorithm:
///
/// $$
/// log_2{x} = n + log_2{y}, \text{ where } y = x*2^{-n}, \ y \in [1, 2)
/// $$
///
/// For $0 \leq x \lt 1$, the input is inverted:
///
/// $$
/// log_2{x} = -log_2{\frac{1}{x}}
/// $$
///
/// @dev See https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation
///
/// Notes:
/// - Due to the lossy precision of the iterative approximation, the results are not perfectly accurate to the last decimal.
///
/// Requirements:
/// - x must be greater than zero.
///
/// @param x The UD60x18 number for which to calculate the binary logarithm.
/// @return result The binary logarithm as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function log2(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
if (xUint < uUNIT) {
revert Errors.PRBMath_UD60x18_Log_InputTooSmall(x);
}
unchecked {
// Calculate the integer part of the logarithm.
uint256 n = Common.msb(xUint / uUNIT);
// This is the integer part of the logarithm as a UD60x18 number. The operation can't overflow because n
// n is at most 255 and UNIT is 1e18.
uint256 resultUint = n * uUNIT;
// Calculate $y = x * 2^{-n}$.
uint256 y = xUint >> n;
// If y is the unit number, the fractional part is zero.
if (y == uUNIT) {
return wrap(resultUint);
}
// Calculate the fractional part via the iterative approximation.
// The `delta >>= 1` part is equivalent to `delta /= 2`, but shifting bits is more gas efficient.
uint256 DOUBLE_UNIT = 2e18;
for (uint256 delta = uHALF_UNIT; delta > 0; delta >>= 1) {
y = (y * y) / uUNIT;
// Is y^2 >= 2e18 and so in the range [2e18, 4e18)?
if (y >= DOUBLE_UNIT) {
// Add the 2^{-m} factor to the logarithm.
resultUint += delta;
// Halve y, which corresponds to z/2 in the Wikipedia article.
y >>= 1;
}
}
result = wrap(resultUint);
}
}
/// @notice Multiplies two UD60x18 numbers together, returning a new UD60x18 number.
///
/// @dev Uses {Common.mulDiv} to enable overflow-safe multiplication and division.
///
/// Notes:
/// - Refer to the notes in {Common.mulDiv}.
///
/// Requirements:
/// - Refer to the requirements in {Common.mulDiv}.
///
/// @dev See the documentation in {Common.mulDiv18}.
/// @param x The multiplicand as a UD60x18 number.
/// @param y The multiplier as a UD60x18 number.
/// @return result The product as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function mul(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(Common.mulDiv18(x.unwrap(), y.unwrap()));
}
/// @notice Raises x to the power of y.
///
/// For $1 \leq x \leq \infty$, the following standard formula is used:
///
/// $$
/// x^y = 2^{log_2{x} * y}
/// $$
///
/// For $0 \leq x \lt 1$, since the unsigned {log2} is undefined, an equivalent formula is used:
///
/// $$
/// i = \frac{1}{x}
/// w = 2^{log_2{i} * y}
/// x^y = \frac{1}{w}
/// $$
///
/// @dev Notes:
/// - Refer to the notes in {log2} and {mul}.
/// - Returns `UNIT` for 0^0.
/// - It may not perform well with very small values of x. Consider using SD59x18 as an alternative.
///
/// Requirements:
/// - Refer to the requirements in {exp2}, {log2}, and {mul}.
///
/// @param x The base as a UD60x18 number.
/// @param y The exponent as a UD60x18 number.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function pow(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
uint256 yUint = y.unwrap();
// If both x and y are zero, the result is `UNIT`. If just x is zero, the result is always zero.
if (xUint == 0) {
return yUint == 0 ? UNIT : ZERO;
}
// If x is `UNIT`, the result is always `UNIT`.
else if (xUint == uUNIT) {
return UNIT;
}
// If y is zero, the result is always `UNIT`.
if (yUint == 0) {
return UNIT;
}
// If y is `UNIT`, the result is always x.
else if (yUint == uUNIT) {
return x;
}
// If x is greater than `UNIT`, use the standard formula.
if (xUint > uUNIT) {
result = exp2(mul(log2(x), y));
}
// Conversely, if x is less than `UNIT`, use the equivalent formula.
else {
UD60x18 i = wrap(uUNIT_SQUARED / xUint);
UD60x18 w = exp2(mul(log2(i), y));
result = wrap(uUNIT_SQUARED / w.unwrap());
}
}
/// @notice Raises x (a UD60x18 number) to the power y (an unsigned basic integer) using the well-known
/// algorithm "exponentiation by squaring".
///
/// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring.
///
/// Notes:
/// - Refer to the notes in {Common.mulDiv18}.
/// - Returns `UNIT` for 0^0.
///
/// Requirements:
/// - The result must fit in UD60x18.
///
/// @param x The base as a UD60x18 number.
/// @param y The exponent as a uint256.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function powu(UD60x18 x, uint256 y) pure returns (UD60x18 result) {
// Calculate the first iteration of the loop in advance.
uint256 xUint = x.unwrap();
uint256 resultUint = y & 1 > 0 ? xUint : uUNIT;
// Equivalent to `for(y /= 2; y > 0; y /= 2)`.
for (y >>= 1; y > 0; y >>= 1) {
xUint = Common.mulDiv18(xUint, xUint);
// Equivalent to `y % 2 == 1`.
if (y & 1 > 0) {
resultUint = Common.mulDiv18(resultUint, xUint);
}
}
result = wrap(resultUint);
}
/// @notice Calculates the square root of x using the Babylonian method.
///
/// @dev See https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
///
/// Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - x must be less than `MAX_UD60x18 / UNIT`.
///
/// @param x The UD60x18 number for which to calculate the square root.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function sqrt(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
unchecked {
if (xUint > uMAX_UD60x18 / uUNIT) {
revert Errors.PRBMath_UD60x18_Sqrt_Overflow(x);
}
// Multiply x by `UNIT` to account for the factor of `UNIT` picked up when multiplying two UD60x18 numbers.
// In this case, the two numbers are both the square root.
result = wrap(Common.sqrt(xUint * uUNIT));
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
import "./Helpers.sol" as Helpers;
import "./Math.sol" as Math;
/// @notice The unsigned 60.18-decimal fixed-point number representation, which can have up to 60 digits and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the Solidity type uint256.
/// @dev The value type is defined here so it can be imported in all other files.
type UD60x18 is uint256;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoSD1x18,
Casting.intoUD2x18,
Casting.intoSD59x18,
Casting.intoUint128,
Casting.intoUint256,
Casting.intoUint40,
Casting.unwrap
} for UD60x18 global;
/*//////////////////////////////////////////////////////////////////////////
MATHEMATICAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
// The global "using for" directive makes the functions in this library callable on the UD60x18 type.
using {
Math.avg,
Math.ceil,
Math.div,
Math.exp,
Math.exp2,
Math.floor,
Math.frac,
Math.gm,
Math.inv,
Math.ln,
Math.log10,
Math.log2,
Math.mul,
Math.pow,
Math.powu,
Math.sqrt
} for UD60x18 global;
/*//////////////////////////////////////////////////////////////////////////
HELPER FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
// The global "using for" directive makes the functions in this library callable on the UD60x18 type.
using {
Helpers.add,
Helpers.and,
Helpers.eq,
Helpers.gt,
Helpers.gte,
Helpers.isZero,
Helpers.lshift,
Helpers.lt,
Helpers.lte,
Helpers.mod,
Helpers.neq,
Helpers.not,
Helpers.or,
Helpers.rshift,
Helpers.sub,
Helpers.uncheckedAdd,
Helpers.uncheckedSub,
Helpers.xor
} for UD60x18 global;
/*//////////////////////////////////////////////////////////////////////////
OPERATORS
//////////////////////////////////////////////////////////////////////////*/
// The global "using for" directive makes it possible to use these operators on the UD60x18 type.
using {
Helpers.add as +,
Helpers.and2 as &,
Math.div as /,
Helpers.eq as ==,
Helpers.gt as >,
Helpers.gte as >=,
Helpers.lt as <,
Helpers.lte as <=,
Helpers.or as |,
Helpers.mod as %,
Math.mul as *,
Helpers.neq as !=,
Helpers.not as ~,
Helpers.sub as -,
Helpers.xor as ^
} for UD60x18 global;
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
// Common.sol
//
// Common mathematical functions used in both SD59x18 and UD60x18. Note that these global functions do not
// always operate with SD59x18 and UD60x18 numbers.
/*//////////////////////////////////////////////////////////////////////////
CUSTOM ERRORS
//////////////////////////////////////////////////////////////////////////*/
/// @notice Thrown when the resultant value in {mulDiv} overflows uint256.
error PRBMath_MulDiv_Overflow(uint256 x, uint256 y, uint256 denominator);
/// @notice Thrown when the resultant value in {mulDiv18} overflows uint256.
error PRBMath_MulDiv18_Overflow(uint256 x, uint256 y);
/// @notice Thrown when one of the inputs passed to {mulDivSigned} is `type(int256).min`.
error PRBMath_MulDivSigned_InputTooSmall();
/// @notice Thrown when the resultant value in {mulDivSigned} overflows int256.
error PRBMath_MulDivSigned_Overflow(int256 x, int256 y);
/*//////////////////////////////////////////////////////////////////////////
CONSTANTS
//////////////////////////////////////////////////////////////////////////*/
/// @dev The maximum value a uint128 number can have.
uint128 constant MAX_UINT128 = type(uint128).max;
/// @dev The maximum value a uint40 number can have.
uint40 constant MAX_UINT40 = type(uint40).max;
/// @dev The unit number, which the decimal precision of the fixed-point types.
uint256 constant UNIT = 1e18;
/// @dev The unit number inverted mod 2^256.
uint256 constant UNIT_INVERSE = 78156646155174841979727994598816262306175212592076161876661_508869554232690281;
/// @dev The the largest power of two that divides the decimal value of `UNIT`. The logarithm of this value is the least significant
/// bit in the binary representation of `UNIT`.
uint256 constant UNIT_LPOTD = 262144;
/*//////////////////////////////////////////////////////////////////////////
FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
/// @notice Calculates the binary exponent of x using the binary fraction method.
/// @dev Has to use 192.64-bit fixed-point numbers. See https://ethereum.stackexchange.com/a/96594/24693.
/// @param x The exponent as an unsigned 192.64-bit fixed-point number.
/// @return result The result as an unsigned 60.18-decimal fixed-point number.
/// @custom:smtchecker abstract-function-nondet
function exp2(uint256 x) pure returns (uint256 result) {
unchecked {
// Start from 0.5 in the 192.64-bit fixed-point format.
result = 0x800000000000000000000000000000000000000000000000;
// The following logic multiplies the result by $\sqrt{2^{-i}}$ when the bit at position i is 1. Key points:
//
// 1. Intermediate results will not overflow, as the starting point is 2^191 and all magic factors are under 2^65.
// 2. The rationale for organizing the if statements into groups of 8 is gas savings. If the result of performing
// a bitwise AND operation between x and any value in the array [0x80; 0x40; 0x20; 0x10; 0x08; 0x04; 0x02; 0x01] is 1,
// we know that `x & 0xFF` is also 1.
if (x & 0xFF00000000000000 > 0) {
if (x & 0x8000000000000000 > 0) {
result = (result * 0x16A09E667F3BCC909) >> 64;
}
if (x & 0x4000000000000000 > 0) {
result = (result * 0x1306FE0A31B7152DF) >> 64;
}
if (x & 0x2000000000000000 > 0) {
result = (result * 0x1172B83C7D517ADCE) >> 64;
}
if (x & 0x1000000000000000 > 0) {
result = (result * 0x10B5586CF9890F62A) >> 64;
}
if (x & 0x800000000000000 > 0) {
result = (result * 0x1059B0D31585743AE) >> 64;
}
if (x & 0x400000000000000 > 0) {
result = (result * 0x102C9A3E778060EE7) >> 64;
}
if (x & 0x200000000000000 > 0) {
result = (result * 0x10163DA9FB33356D8) >> 64;
}
if (x & 0x100000000000000 > 0) {
result = (result * 0x100B1AFA5ABCBED61) >> 64;
}
}
if (x & 0xFF000000000000 > 0) {
if (x & 0x80000000000000 > 0) {
result = (result * 0x10058C86DA1C09EA2) >> 64;
}
if (x & 0x40000000000000 > 0) {
result = (result * 0x1002C605E2E8CEC50) >> 64;
}
if (x & 0x20000000000000 > 0) {
result = (result * 0x100162F3904051FA1) >> 64;
}
if (x & 0x10000000000000 > 0) {
result = (result * 0x1000B175EFFDC76BA) >> 64;
}
if (x & 0x8000000000000 > 0) {
result = (result * 0x100058BA01FB9F96D) >> 64;
}
if (x & 0x4000000000000 > 0) {
result = (result * 0x10002C5CC37DA9492) >> 64;
}
if (x & 0x2000000000000 > 0) {
result = (result * 0x1000162E525EE0547) >> 64;
}
if (x & 0x1000000000000 > 0) {
result = (result * 0x10000B17255775C04) >> 64;
}
}
if (x & 0xFF0000000000 > 0) {
if (x & 0x800000000000 > 0) {
result = (result * 0x1000058B91B5BC9AE) >> 64;
}
if (x & 0x400000000000 > 0) {
result = (result * 0x100002C5C89D5EC6D) >> 64;
}
if (x & 0x200000000000 > 0) {
result = (result * 0x10000162E43F4F831) >> 64;
}
if (x & 0x100000000000 > 0) {
result = (result * 0x100000B1721BCFC9A) >> 64;
}
if (x & 0x80000000000 > 0) {
result = (result * 0x10000058B90CF1E6E) >> 64;
}
if (x & 0x40000000000 > 0) {
result = (result * 0x1000002C5C863B73F) >> 64;
}
if (x & 0x20000000000 > 0) {
result = (result * 0x100000162E430E5A2) >> 64;
}
if (x & 0x10000000000 > 0) {
result = (result * 0x1000000B172183551) >> 64;
}
}
if (x & 0xFF00000000 > 0) {
if (x & 0x8000000000 > 0) {
result = (result * 0x100000058B90C0B49) >> 64;
}
if (x & 0x4000000000 > 0) {
result = (result * 0x10000002C5C8601CC) >> 64;
}
if (x & 0x2000000000 > 0) {
result = (result * 0x1000000162E42FFF0) >> 64;
}
if (x & 0x1000000000 > 0) {
result = (result * 0x10000000B17217FBB) >> 64;
}
if (x & 0x800000000 > 0) {
result = (result * 0x1000000058B90BFCE) >> 64;
}
if (x & 0x400000000 > 0) {
result = (result * 0x100000002C5C85FE3) >> 64;
}
if (x & 0x200000000 > 0) {
result = (result * 0x10000000162E42FF1) >> 64;
}
if (x & 0x100000000 > 0) {
result = (result * 0x100000000B17217F8) >> 64;
}
}
if (x & 0xFF000000 > 0) {
if (x & 0x80000000 > 0) {
result = (result * 0x10000000058B90BFC) >> 64;
}
if (x & 0x40000000 > 0) {
result = (result * 0x1000000002C5C85FE) >> 64;
}
if (x & 0x20000000 > 0) {
result = (result * 0x100000000162E42FF) >> 64;
}
if (x & 0x10000000 > 0) {
result = (result * 0x1000000000B17217F) >> 64;
}
if (x & 0x8000000 > 0) {
result = (result * 0x100000000058B90C0) >> 64;
}
if (x & 0x4000000 > 0) {
result = (result * 0x10000000002C5C860) >> 64;
}
if (x & 0x2000000 > 0) {
result = (result * 0x1000000000162E430) >> 64;
}
if (x & 0x1000000 > 0) {
result = (result * 0x10000000000B17218) >> 64;
}
}
if (x & 0xFF0000 > 0) {
if (x & 0x800000 > 0) {
result = (result * 0x1000000000058B90C) >> 64;
}
if (x & 0x400000 > 0) {
result = (result * 0x100000000002C5C86) >> 64;
}
if (x & 0x200000 > 0) {
result = (result * 0x10000000000162E43) >> 64;
}
if (x & 0x100000 > 0) {
result = (result * 0x100000000000B1721) >> 64;
}
if (x & 0x80000 > 0) {
result = (result * 0x10000000000058B91) >> 64;
}
if (x & 0x40000 > 0) {
result = (result * 0x1000000000002C5C8) >> 64;
}
if (x & 0x20000 > 0) {
result = (result * 0x100000000000162E4) >> 64;
}
if (x & 0x10000 > 0) {
result = (result * 0x1000000000000B172) >> 64;
}
}
if (x & 0xFF00 > 0) {
if (x & 0x8000 > 0) {
result = (result * 0x100000000000058B9) >> 64;
}
if (x & 0x4000 > 0) {
result = (result * 0x10000000000002C5D) >> 64;
}
if (x & 0x2000 > 0) {
result = (result * 0x1000000000000162E) >> 64;
}
if (x & 0x1000 > 0) {
result = (result * 0x10000000000000B17) >> 64;
}
if (x & 0x800 > 0) {
result = (result * 0x1000000000000058C) >> 64;
}
if (x & 0x400 > 0) {
result = (result * 0x100000000000002C6) >> 64;
}
if (x & 0x200 > 0) {
result = (result * 0x10000000000000163) >> 64;
}
if (x & 0x100 > 0) {
result = (result * 0x100000000000000B1) >> 64;
}
}
if (x & 0xFF > 0) {
if (x & 0x80 > 0) {
result = (result * 0x10000000000000059) >> 64;
}
if (x & 0x40 > 0) {
result = (result * 0x1000000000000002C) >> 64;
}
if (x & 0x20 > 0) {
result = (result * 0x10000000000000016) >> 64;
}
if (x & 0x10 > 0) {
result = (result * 0x1000000000000000B) >> 64;
}
if (x & 0x8 > 0) {
result = (result * 0x10000000000000006) >> 64;
}
if (x & 0x4 > 0) {
result = (result * 0x10000000000000003) >> 64;
}
if (x & 0x2 > 0) {
result = (result * 0x10000000000000001) >> 64;
}
if (x & 0x1 > 0) {
result = (result * 0x10000000000000001) >> 64;
}
}
// In the code snippet below, two operations are executed simultaneously:
//
// 1. The result is multiplied by $(2^n + 1)$, where $2^n$ represents the integer part, and the additional 1
// accounts for the initial guess of 0.5. This is achieved by subtracting from 191 instead of 192.
// 2. The result is then converted to an unsigned 60.18-decimal fixed-point format.
//
// The underlying logic is based on the relationship $2^{191-ip} = 2^{ip} / 2^{191}$, where $ip$ denotes the,
// integer part, $2^n$.
result *= UNIT;
result >>= (191 - (x >> 64));
}
}
/// @notice Finds the zero-based index of the first 1 in the binary representation of x.
///
/// @dev See the note on "msb" in this Wikipedia article: https://en.wikipedia.org/wiki/Find_first_set
///
/// Each step in this implementation is equivalent to this high-level code:
///
/// ```solidity
/// if (x >= 2 ** 128) {
/// x >>= 128;
/// result += 128;
/// }
/// ```
///
/// Where 128 is replaced with each respective power of two factor. See the full high-level implementation here:
/// https://gist.github.com/PaulRBerg/f932f8693f2733e30c4d479e8e980948
///
/// The Yul instructions used below are:
///
/// - "gt" is "greater than"
/// - "or" is the OR bitwise operator
/// - "shl" is "shift left"
/// - "shr" is "shift right"
///
/// @param x The uint256 number for which to find the index of the most significant bit.
/// @return result The index of the most significant bit as a uint256.
/// @custom:smtchecker abstract-function-nondet
function msb(uint256 x) pure returns (uint256 result) {
// 2^128
assembly ("memory-safe") {
let factor := shl(7, gt(x, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^64
assembly ("memory-safe") {
let factor := shl(6, gt(x, 0xFFFFFFFFFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^32
assembly ("memory-safe") {
let factor := shl(5, gt(x, 0xFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^16
assembly ("memory-safe") {
let factor := shl(4, gt(x, 0xFFFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^8
assembly ("memory-safe") {
let factor := shl(3, gt(x, 0xFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^4
assembly ("memory-safe") {
let factor := shl(2, gt(x, 0xF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^2
assembly ("memory-safe") {
let factor := shl(1, gt(x, 0x3))
x := shr(factor, x)
result := or(result, factor)
}
// 2^1
// No need to shift x any more.
assembly ("memory-safe") {
let factor := gt(x, 0x1)
result := or(result, factor)
}
}
/// @notice Calculates x*y÷denominator with 512-bit precision.
///
/// @dev Credits to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.
///
/// Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - The denominator must not be zero.
/// - The result must fit in uint256.
///
/// @param x The multiplicand as a uint256.
/// @param y The multiplier as a uint256.
/// @param denominator The divisor as a uint256.
/// @return result The result as a uint256.
/// @custom:smtchecker abstract-function-nondet
function mulDiv(uint256 x, uint256 y, uint256 denominator) pure returns (uint256 result) {
// 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; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly ("memory-safe") {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
unchecked {
return prod0 / denominator;
}
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
if (prod1 >= denominator) {
revert PRBMath_MulDiv_Overflow(x, y, denominator);
}
////////////////////////////////////////////////////////////////////////////
// 512 by 256 division
////////////////////////////////////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly ("memory-safe") {
// Compute remainder using the mulmod Yul instruction.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512-bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
unchecked {
// Calculate the largest power of two divisor of the denominator using the unary operator ~. This operation cannot overflow
// because the denominator cannot be zero at this point in the function execution. The result is always >= 1.
// For more detail, see https://cs.stackexchange.com/q/138556/92363.
uint256 lpotdod = denominator & (~denominator + 1);
uint256 flippedLpotdod;
assembly ("memory-safe") {
// Factor powers of two out of denominator.
denominator := div(denominator, lpotdod)
// Divide [prod1 prod0] by lpotdod.
prod0 := div(prod0, lpotdod)
// Get the flipped value `2^256 / lpotdod`. If the `lpotdod` is zero, the flipped value is one.
// `sub(0, lpotdod)` produces the two's complement version of `lpotdod`, which is equivalent to flipping all the bits.
// However, `div` interprets this value as an unsigned value: https://ethereum.stackexchange.com/q/147168/24693
flippedLpotdod := add(div(sub(0, lpotdod), lpotdod), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * flippedLpotdod;
// 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;
}
}
/// @notice Calculates x*y÷1e18 with 512-bit precision.
///
/// @dev A variant of {mulDiv} with constant folding, i.e. in which the denominator is hard coded to 1e18.
///
/// Notes:
/// - The body is purposely left uncommented; to understand how this works, see the documentation in {mulDiv}.
/// - The result is rounded toward zero.
/// - We take as an axiom that the result cannot be `MAX_UINT256` when x and y solve the following system of equations:
///
/// $$
/// \begin{cases}
/// x * y = MAX\_UINT256 * UNIT \\
/// (x * y) \% UNIT \geq \frac{UNIT}{2}
/// \end{cases}
/// $$
///
/// Requirements:
/// - Refer to the requirements in {mulDiv}.
/// - The result must fit in uint256.
///
/// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
/// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
/// @return result The result as an unsigned 60.18-decimal fixed-point number.
/// @custom:smtchecker abstract-function-nondet
function mulDiv18(uint256 x, uint256 y) pure returns (uint256 result) {
uint256 prod0;
uint256 prod1;
assembly ("memory-safe") {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
unchecked {
return prod0 / UNIT;
}
}
if (prod1 >= UNIT) {
revert PRBMath_MulDiv18_Overflow(x, y);
}
uint256 remainder;
assembly ("memory-safe") {
remainder := mulmod(x, y, UNIT)
result :=
mul(
or(
div(sub(prod0, remainder), UNIT_LPOTD),
mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, UNIT_LPOTD), UNIT_LPOTD), 1))
),
UNIT_INVERSE
)
}
}
/// @notice Calculates x*y÷denominator with 512-bit precision.
///
/// @dev This is an extension of {mulDiv} for signed numbers, which works by computing the signs and the absolute values separately.
///
/// Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - Refer to the requirements in {mulDiv}.
/// - None of the inputs can be `type(int256).min`.
/// - The result must fit in int256.
///
/// @param x The multiplicand as an int256.
/// @param y The multiplier as an int256.
/// @param denominator The divisor as an int256.
/// @return result The result as an int256.
/// @custom:smtchecker abstract-function-nondet
function mulDivSigned(int256 x, int256 y, int256 denominator) pure returns (int256 result) {
if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) {
revert PRBMath_MulDivSigned_InputTooSmall();
}
// Get hold of the absolute values of x, y and the denominator.
uint256 xAbs;
uint256 yAbs;
uint256 dAbs;
unchecked {
xAbs = x < 0 ? uint256(-x) : uint256(x);
yAbs = y < 0 ? uint256(-y) : uint256(y);
dAbs = denominator < 0 ? uint256(-denominator) : uint256(denominator);
}
// Compute the absolute value of x*y÷denominator. The result must fit in int256.
uint256 resultAbs = mulDiv(xAbs, yAbs, dAbs);
if (resultAbs > uint256(type(int256).max)) {
revert PRBMath_MulDivSigned_Overflow(x, y);
}
// Get the signs of x, y and the denominator.
uint256 sx;
uint256 sy;
uint256 sd;
assembly ("memory-safe") {
// "sgt" is the "signed greater than" assembly instruction and "sub(0,1)" is -1 in two's complement.
sx := sgt(x, sub(0, 1))
sy := sgt(y, sub(0, 1))
sd := sgt(denominator, sub(0, 1))
}
// XOR over sx, sy and sd. What this does is to check whether there are 1 or 3 negative signs in the inputs.
// If there are, the result should be negative. Otherwise, it should be positive.
unchecked {
result = sx ^ sy ^ sd == 0 ? -int256(resultAbs) : int256(resultAbs);
}
}
/// @notice Calculates the square root of x using the Babylonian method.
///
/// @dev See https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
///
/// Notes:
/// - If x is not a perfect square, the result is rounded down.
/// - Credits to OpenZeppelin for the explanations in comments below.
///
/// @param x The uint256 number for which to calculate the square root.
/// @return result The result as a uint256.
/// @custom:smtchecker abstract-function-nondet
function sqrt(uint256 x) pure returns (uint256 result) {
if (x == 0) {
return 0;
}
// For our first guess, we calculate the biggest power of 2 which is smaller than the square root of x.
//
// We know that the "msb" (most significant bit) of x is a power of 2 such that we have:
//
// $$
// msb(x) <= x <= 2*msb(x)$
// $$
//
// We write $msb(x)$ as $2^k$, and we get:
//
// $$
// k = log_2(x)
// $$
//
// Thus, we can write the initial inequality as:
//
// $$
// 2^{log_2(x)} <= x <= 2*2^{log_2(x)+1} \\
// sqrt(2^k) <= sqrt(x) < sqrt(2^{k+1}) \\
// 2^{k/2} <= sqrt(x) < 2^{(k+1)/2} <= 2^{(k/2)+1}
// $$
//
// Consequently, $2^{log_2(x) /2} is a good first approximation of sqrt(x) with at least one correct bit.
uint256 xAux = uint256(x);
result = 1;
if (xAux >= 2 ** 128) {
xAux >>= 128;
result <<= 64;
}
if (xAux >= 2 ** 64) {
xAux >>= 64;
result <<= 32;
}
if (xAux >= 2 ** 32) {
xAux >>= 32;
result <<= 16;
}
if (xAux >= 2 ** 16) {
xAux >>= 16;
result <<= 8;
}
if (xAux >= 2 ** 8) {
xAux >>= 8;
result <<= 4;
}
if (xAux >= 2 ** 4) {
xAux >>= 4;
result <<= 2;
}
if (xAux >= 2 ** 2) {
result <<= 1;
}
// At this point, `result` is an estimation with at least one bit of precision. We know the true value has at
// most 128 bits, 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 + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
// If x is not a perfect square, round the result toward zero.
uint256 roundedResult = x / result;
if (result >= roundedResult) {
result = roundedResult;
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD1x18 } from "./ValueType.sol";
/// @dev Euler's number as an SD1x18 number.
SD1x18 constant E = SD1x18.wrap(2_718281828459045235);
/// @dev The maximum value an SD1x18 number can have.
int64 constant uMAX_SD1x18 = 9_223372036854775807;
SD1x18 constant MAX_SD1x18 = SD1x18.wrap(uMAX_SD1x18);
/// @dev The maximum value an SD1x18 number can have.
int64 constant uMIN_SD1x18 = -9_223372036854775808;
SD1x18 constant MIN_SD1x18 = SD1x18.wrap(uMIN_SD1x18);
/// @dev PI as an SD1x18 number.
SD1x18 constant PI = SD1x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of SD1x18.
SD1x18 constant UNIT = SD1x18.wrap(1e18);
int256 constant uUNIT = 1e18;
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
/// @notice The signed 1.18-decimal fixed-point number representation, which can have up to 1 digit and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity
/// type int64. This is useful when end users want to use int64 to save gas, e.g. with tight variable packing in contract
/// storage.
type SD1x18 is int64;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoSD59x18,
Casting.intoUD2x18,
Casting.intoUD60x18,
Casting.intoUint256,
Casting.intoUint128,
Casting.intoUint40,
Casting.unwrap
} for SD1x18 global;
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD59x18 } from "./ValueType.sol";
// NOTICE: the "u" prefix stands for "unwrapped".
/// @dev Euler's number as an SD59x18 number.
SD59x18 constant E = SD59x18.wrap(2_718281828459045235);
/// @dev The maximum input permitted in {exp}.
int256 constant uEXP_MAX_INPUT = 133_084258667509499440;
SD59x18 constant EXP_MAX_INPUT = SD59x18.wrap(uEXP_MAX_INPUT);
/// @dev The maximum input permitted in {exp2}.
int256 constant uEXP2_MAX_INPUT = 192e18 - 1;
SD59x18 constant EXP2_MAX_INPUT = SD59x18.wrap(uEXP2_MAX_INPUT);
/// @dev Half the UNIT number.
int256 constant uHALF_UNIT = 0.5e18;
SD59x18 constant HALF_UNIT = SD59x18.wrap(uHALF_UNIT);
/// @dev $log_2(10)$ as an SD59x18 number.
int256 constant uLOG2_10 = 3_321928094887362347;
SD59x18 constant LOG2_10 = SD59x18.wrap(uLOG2_10);
/// @dev $log_2(e)$ as an SD59x18 number.
int256 constant uLOG2_E = 1_442695040888963407;
SD59x18 constant LOG2_E = SD59x18.wrap(uLOG2_E);
/// @dev The maximum value an SD59x18 number can have.
int256 constant uMAX_SD59x18 = 57896044618658097711785492504343953926634992332820282019728_792003956564819967;
SD59x18 constant MAX_SD59x18 = SD59x18.wrap(uMAX_SD59x18);
/// @dev The maximum whole value an SD59x18 number can have.
int256 constant uMAX_WHOLE_SD59x18 = 57896044618658097711785492504343953926634992332820282019728_000000000000000000;
SD59x18 constant MAX_WHOLE_SD59x18 = SD59x18.wrap(uMAX_WHOLE_SD59x18);
/// @dev The minimum value an SD59x18 number can have.
int256 constant uMIN_SD59x18 = -57896044618658097711785492504343953926634992332820282019728_792003956564819968;
SD59x18 constant MIN_SD59x18 = SD59x18.wrap(uMIN_SD59x18);
/// @dev The minimum whole value an SD59x18 number can have.
int256 constant uMIN_WHOLE_SD59x18 = -57896044618658097711785492504343953926634992332820282019728_000000000000000000;
SD59x18 constant MIN_WHOLE_SD59x18 = SD59x18.wrap(uMIN_WHOLE_SD59x18);
/// @dev PI as an SD59x18 number.
SD59x18 constant PI = SD59x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of SD59x18.
int256 constant uUNIT = 1e18;
SD59x18 constant UNIT = SD59x18.wrap(1e18);
/// @dev The unit number squared.
int256 constant uUNIT_SQUARED = 1e36;
SD59x18 constant UNIT_SQUARED = SD59x18.wrap(uUNIT_SQUARED);
/// @dev Zero as an SD59x18 number.
SD59x18 constant ZERO = SD59x18.wrap(0);
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
import "./Helpers.sol" as Helpers;
import "./Math.sol" as Math;
/// @notice The signed 59.18-decimal fixed-point number representation, which can have up to 59 digits and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity
/// type int256.
type SD59x18 is int256;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoInt256,
Casting.intoSD1x18,
Casting.intoUD2x18,
Casting.intoUD60x18,
Casting.intoUint256,
Casting.intoUint128,
Casting.intoUint40,
Casting.unwrap
} for SD59x18 global;
/*//////////////////////////////////////////////////////////////////////////
MATHEMATICAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
using {
Math.abs,
Math.avg,
Math.ceil,
Math.div,
Math.exp,
Math.exp2,
Math.floor,
Math.frac,
Math.gm,
Math.inv,
Math.log10,
Math.log2,
Math.ln,
Math.mul,
Math.pow,
Math.powu,
Math.sqrt
} for SD59x18 global;
/*//////////////////////////////////////////////////////////////////////////
HELPER FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
using {
Helpers.add,
Helpers.and,
Helpers.eq,
Helpers.gt,
Helpers.gte,
Helpers.isZero,
Helpers.lshift,
Helpers.lt,
Helpers.lte,
Helpers.mod,
Helpers.neq,
Helpers.not,
Helpers.or,
Helpers.rshift,
Helpers.sub,
Helpers.uncheckedAdd,
Helpers.uncheckedSub,
Helpers.uncheckedUnary,
Helpers.xor
} for SD59x18 global;
/*//////////////////////////////////////////////////////////////////////////
OPERATORS
//////////////////////////////////////////////////////////////////////////*/
// The global "using for" directive makes it possible to use these operators on the SD59x18 type.
using {
Helpers.add as +,
Helpers.and2 as &,
Math.div as /,
Helpers.eq as ==,
Helpers.gt as >,
Helpers.gte as >=,
Helpers.lt as <,
Helpers.lte as <=,
Helpers.mod as %,
Math.mul as *,
Helpers.neq as !=,
Helpers.not as ~,
Helpers.or as |,
Helpers.sub as -,
Helpers.unary as -,
Helpers.xor as ^
} for SD59x18 global;
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD2x18 } from "./ValueType.sol";
/// @dev Euler's number as a UD2x18 number.
UD2x18 constant E = UD2x18.wrap(2_718281828459045235);
/// @dev The maximum value a UD2x18 number can have.
uint64 constant uMAX_UD2x18 = 18_446744073709551615;
UD2x18 constant MAX_UD2x18 = UD2x18.wrap(uMAX_UD2x18);
/// @dev PI as a UD2x18 number.
UD2x18 constant PI = UD2x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of UD2x18.
uint256 constant uUNIT = 1e18;
UD2x18 constant UNIT = UD2x18.wrap(1e18);
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
/// @notice The unsigned 2.18-decimal fixed-point number representation, which can have up to 2 digits and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity
/// type uint64. This is useful when end users want to use uint64 to save gas, e.g. with tight variable packing in contract
/// storage.
type UD2x18 is uint64;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoSD1x18,
Casting.intoSD59x18,
Casting.intoUD60x18,
Casting.intoUint256,
Casting.intoUint128,
Casting.intoUint40,
Casting.unwrap
} for UD2x18 global;
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as CastingErrors;
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { UD2x18 } from "../ud2x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
import { SD1x18 } from "./ValueType.sol";
/// @notice Casts an SD1x18 number into SD59x18.
/// @dev There is no overflow check because the domain of SD1x18 is a subset of SD59x18.
function intoSD59x18(SD1x18 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(int256(SD1x18.unwrap(x)));
}
/// @notice Casts an SD1x18 number into UD2x18.
/// - x must be positive.
function intoUD2x18(SD1x18 x) pure returns (UD2x18 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUD2x18_Underflow(x);
}
result = UD2x18.wrap(uint64(xInt));
}
/// @notice Casts an SD1x18 number into UD60x18.
/// @dev Requirements:
/// - x must be positive.
function intoUD60x18(SD1x18 x) pure returns (UD60x18 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUD60x18_Underflow(x);
}
result = UD60x18.wrap(uint64(xInt));
}
/// @notice Casts an SD1x18 number into uint256.
/// @dev Requirements:
/// - x must be positive.
function intoUint256(SD1x18 x) pure returns (uint256 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUint256_Underflow(x);
}
result = uint256(uint64(xInt));
}
/// @notice Casts an SD1x18 number into uint128.
/// @dev Requirements:
/// - x must be positive.
function intoUint128(SD1x18 x) pure returns (uint128 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUint128_Underflow(x);
}
result = uint128(uint64(xInt));
}
/// @notice Casts an SD1x18 number into uint40.
/// @dev Requirements:
/// - x must be positive.
/// - x must be less than or equal to `MAX_UINT40`.
function intoUint40(SD1x18 x) pure returns (uint40 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUint40_Underflow(x);
}
if (xInt > int64(uint64(Common.MAX_UINT40))) {
revert CastingErrors.PRBMath_SD1x18_ToUint40_Overflow(x);
}
result = uint40(uint64(xInt));
}
/// @notice Alias for {wrap}.
function sd1x18(int64 x) pure returns (SD1x18 result) {
result = SD1x18.wrap(x);
}
/// @notice Unwraps an SD1x18 number into int64.
function unwrap(SD1x18 x) pure returns (int64 result) {
result = SD1x18.unwrap(x);
}
/// @notice Wraps an int64 number into SD1x18.
function wrap(int64 x) pure returns (SD1x18 result) {
result = SD1x18.wrap(x);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Errors.sol" as CastingErrors;
import { MAX_UINT128, MAX_UINT40 } from "../Common.sol";
import { uMAX_SD1x18, uMIN_SD1x18 } from "../sd1x18/Constants.sol";
import { SD1x18 } from "../sd1x18/ValueType.sol";
import { uMAX_UD2x18 } from "../ud2x18/Constants.sol";
import { UD2x18 } from "../ud2x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
import { SD59x18 } from "./ValueType.sol";
/// @notice Casts an SD59x18 number into int256.
/// @dev This is basically a functional alias for {unwrap}.
function intoInt256(SD59x18 x) pure returns (int256 result) {
result = SD59x18.unwrap(x);
}
/// @notice Casts an SD59x18 number into SD1x18.
/// @dev Requirements:
/// - x must be greater than or equal to `uMIN_SD1x18`.
/// - x must be less than or equal to `uMAX_SD1x18`.
function intoSD1x18(SD59x18 x) pure returns (SD1x18 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < uMIN_SD1x18) {
revert CastingErrors.PRBMath_SD59x18_IntoSD1x18_Underflow(x);
}
if (xInt > uMAX_SD1x18) {
revert CastingErrors.PRBMath_SD59x18_IntoSD1x18_Overflow(x);
}
result = SD1x18.wrap(int64(xInt));
}
/// @notice Casts an SD59x18 number into UD2x18.
/// @dev Requirements:
/// - x must be positive.
/// - x must be less than or equal to `uMAX_UD2x18`.
function intoUD2x18(SD59x18 x) pure returns (UD2x18 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUD2x18_Underflow(x);
}
if (xInt > int256(uint256(uMAX_UD2x18))) {
revert CastingErrors.PRBMath_SD59x18_IntoUD2x18_Overflow(x);
}
result = UD2x18.wrap(uint64(uint256(xInt)));
}
/// @notice Casts an SD59x18 number into UD60x18.
/// @dev Requirements:
/// - x must be positive.
function intoUD60x18(SD59x18 x) pure returns (UD60x18 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUD60x18_Underflow(x);
}
result = UD60x18.wrap(uint256(xInt));
}
/// @notice Casts an SD59x18 number into uint256.
/// @dev Requirements:
/// - x must be positive.
function intoUint256(SD59x18 x) pure returns (uint256 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUint256_Underflow(x);
}
result = uint256(xInt);
}
/// @notice Casts an SD59x18 number into uint128.
/// @dev Requirements:
/// - x must be positive.
/// - x must be less than or equal to `uMAX_UINT128`.
function intoUint128(SD59x18 x) pure returns (uint128 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUint128_Underflow(x);
}
if (xInt > int256(uint256(MAX_UINT128))) {
revert CastingErrors.PRBMath_SD59x18_IntoUint128_Overflow(x);
}
result = uint128(uint256(xInt));
}
/// @notice Casts an SD59x18 number into uint40.
/// @dev Requirements:
/// - x must be positive.
/// - x must be less than or equal to `MAX_UINT40`.
function intoUint40(SD59x18 x) pure returns (uint40 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUint40_Underflow(x);
}
if (xInt > int256(uint256(MAX_UINT40))) {
revert CastingErrors.PRBMath_SD59x18_IntoUint40_Overflow(x);
}
result = uint40(uint256(xInt));
}
/// @notice Alias for {wrap}.
function sd(int256 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(x);
}
/// @notice Alias for {wrap}.
function sd59x18(int256 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(x);
}
/// @notice Unwraps an SD59x18 number into int256.
function unwrap(SD59x18 x) pure returns (int256 result) {
result = SD59x18.unwrap(x);
}
/// @notice Wraps an int256 number into SD59x18.
function wrap(int256 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(x);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { wrap } from "./Casting.sol";
import { SD59x18 } from "./ValueType.sol";
/// @notice Implements the checked addition operation (+) in the SD59x18 type.
function add(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
return wrap(x.unwrap() + y.unwrap());
}
/// @notice Implements the AND (&) bitwise operation in the SD59x18 type.
function and(SD59x18 x, int256 bits) pure returns (SD59x18 result) {
return wrap(x.unwrap() & bits);
}
/// @notice Implements the AND (&) bitwise operation in the SD59x18 type.
function and2(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
return wrap(x.unwrap() & y.unwrap());
}
/// @notice Implements the equal (=) operation in the SD59x18 type.
function eq(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() == y.unwrap();
}
/// @notice Implements the greater than operation (>) in the SD59x18 type.
function gt(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() > y.unwrap();
}
/// @notice Implements the greater than or equal to operation (>=) in the SD59x18 type.
function gte(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() >= y.unwrap();
}
/// @notice Implements a zero comparison check function in the SD59x18 type.
function isZero(SD59x18 x) pure returns (bool result) {
result = x.unwrap() == 0;
}
/// @notice Implements the left shift operation (<<) in the SD59x18 type.
function lshift(SD59x18 x, uint256 bits) pure returns (SD59x18 result) {
result = wrap(x.unwrap() << bits);
}
/// @notice Implements the lower than operation (<) in the SD59x18 type.
function lt(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() < y.unwrap();
}
/// @notice Implements the lower than or equal to operation (<=) in the SD59x18 type.
function lte(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() <= y.unwrap();
}
/// @notice Implements the unchecked modulo operation (%) in the SD59x18 type.
function mod(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
result = wrap(x.unwrap() % y.unwrap());
}
/// @notice Implements the not equal operation (!=) in the SD59x18 type.
function neq(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() != y.unwrap();
}
/// @notice Implements the NOT (~) bitwise operation in the SD59x18 type.
function not(SD59x18 x) pure returns (SD59x18 result) {
result = wrap(~x.unwrap());
}
/// @notice Implements the OR (|) bitwise operation in the SD59x18 type.
function or(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
result = wrap(x.unwrap() | y.unwrap());
}
/// @notice Implements the right shift operation (>>) in the SD59x18 type.
function rshift(SD59x18 x, uint256 bits) pure returns (SD59x18 result) {
result = wrap(x.unwrap() >> bits);
}
/// @notice Implements the checked subtraction operation (-) in the SD59x18 type.
function sub(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
result = wrap(x.unwrap() - y.unwrap());
}
/// @notice Implements the checked unary minus operation (-) in the SD59x18 type.
function unary(SD59x18 x) pure returns (SD59x18 result) {
result = wrap(-x.unwrap());
}
/// @notice Implements the unchecked addition operation (+) in the SD59x18 type.
function uncheckedAdd(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
unchecked {
result = wrap(x.unwrap() + y.unwrap());
}
}
/// @notice Implements the unchecked subtraction operation (-) in the SD59x18 type.
function uncheckedSub(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
unchecked {
result = wrap(x.unwrap() - y.unwrap());
}
}
/// @notice Implements the unchecked unary minus operation (-) in the SD59x18 type.
function uncheckedUnary(SD59x18 x) pure returns (SD59x18 result) {
unchecked {
result = wrap(-x.unwrap());
}
}
/// @notice Implements the XOR (^) bitwise operation in the SD59x18 type.
function xor(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
result = wrap(x.unwrap() ^ y.unwrap());
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as Errors;
import {
uEXP_MAX_INPUT,
uEXP2_MAX_INPUT,
uHALF_UNIT,
uLOG2_10,
uLOG2_E,
uMAX_SD59x18,
uMAX_WHOLE_SD59x18,
uMIN_SD59x18,
uMIN_WHOLE_SD59x18,
UNIT,
uUNIT,
uUNIT_SQUARED,
ZERO
} from "./Constants.sol";
import { wrap } from "./Helpers.sol";
import { SD59x18 } from "./ValueType.sol";
/// @notice Calculates the absolute value of x.
///
/// @dev Requirements:
/// - x must be greater than `MIN_SD59x18`.
///
/// @param x The SD59x18 number for which to calculate the absolute value.
/// @param result The absolute value of x as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function abs(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
if (xInt == uMIN_SD59x18) {
revert Errors.PRBMath_SD59x18_Abs_MinSD59x18();
}
result = xInt < 0 ? wrap(-xInt) : x;
}
/// @notice Calculates the arithmetic average of x and y.
///
/// @dev Notes:
/// - The result is rounded toward zero.
///
/// @param x The first operand as an SD59x18 number.
/// @param y The second operand as an SD59x18 number.
/// @return result The arithmetic average as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function avg(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
int256 yInt = y.unwrap();
unchecked {
// This operation is equivalent to `x / 2 + y / 2`, and it can never overflow.
int256 sum = (xInt >> 1) + (yInt >> 1);
if (sum < 0) {
// If at least one of x and y is odd, add 1 to the result, because shifting negative numbers to the right
// rounds toward negative infinity. The right part is equivalent to `sum + (x % 2 == 1 || y % 2 == 1)`.
assembly ("memory-safe") {
result := add(sum, and(or(xInt, yInt),