Source Code
Overview
ETH Balance
0 ETH
ETH Value
$0.00Multichain Info
N/A
Loading...
Loading
Contract Name:
BorrowSwap
Compiler Version
v0.8.11+commit.d7f03943
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "./BorrowSwap_G3.sol";
contract BorrowSwap is BorrowSwap_G3 {
constructor(
address _tellerV2,
address _swapRouter,
address _quoter
)
BorrowSwap_G3(
_tellerV2,
_swapRouter,
_quoter
)
{}
}// 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 (last updated v4.8.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721Upgradeable is IERC165Upgradeable {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) 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
// 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.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 (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
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.0;
/**
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*
* Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
* all math on `uint256` and `int256` and then downcasting.
*/
library SafeCast {
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*
* _Available since v4.7._
*/
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*
* _Available since v4.7._
*/
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*
* _Available since v4.7._
*/
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*
* _Available since v4.2._
*/
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*
* _Available since v4.7._
*/
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*
* _Available since v4.7._
*/
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*
* _Available since v4.7._
*/
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*
* _Available since v4.7._
*/
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*
* _Available since v4.7._
*/
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*
* _Available since v4.7._
*/
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*
* _Available since v4.7._
*/
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*
* _Available since v4.7._
*/
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*
* _Available since v4.7._
*/
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*
* _Available since v4.7._
*/
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*
* _Available since v4.7._
*/
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v2.5._
*/
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*
* _Available since v4.7._
*/
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*
* _Available since v4.7._
*/
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*
* _Available since v4.7._
*/
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*
* _Available since v4.2._
*/
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*
* _Available since v4.7._
*/
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*
* _Available since v4.7._
*/
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*
* _Available since v4.7._
*/
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v2.5._
*/
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*
* _Available since v4.7._
*/
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*
* _Available since v4.7._
*/
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*
* _Available since v4.7._
*/
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v2.5._
*/
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*
* _Available since v4.7._
*/
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v2.5._
*/
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*
* _Available since v2.5._
*/
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*
* _Available since v3.0._
*/
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*
* _Available since v4.7._
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*
* _Available since v4.7._
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*
* _Available since v4.7._
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*
* _Available since v4.7._
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*
* _Available since v4.7._
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*
* _Available since v4.7._
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*
* _Available since v4.7._
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*
* _Available since v4.7._
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*
* _Available since v4.7._
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*
* _Available since v4.7._
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*
* _Available since v4.7._
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*
* _Available since v4.7._
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*
* _Available since v4.7._
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*
* _Available since v4.7._
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*
* _Available since v4.7._
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*
* _Available since v3.1._
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*
* _Available since v4.7._
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*
* _Available since v4.7._
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*
* _Available since v4.7._
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*
* _Available since v4.7._
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*
* _Available since v4.7._
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*
* _Available since v4.7._
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*
* _Available since v4.7._
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*
* _Available since v3.1._
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*
* _Available since v4.7._
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*
* _Available since v4.7._
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*
* _Available since v4.7._
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*
* _Available since v3.1._
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*
* _Available since v4.7._
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*
* _Available since v3.1._
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*
* _Available since v3.1._
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*
* _Available since v3.0._
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
* @dev Wrappers over Solidity's arithmetic operations.
*
* NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
* now has built in overflow checking.
*/
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}// 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;
}
}pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: MIT
import "../Types.sol";
import "../interfaces/IEAS.sol";
import "../interfaces/IASRegistry.sol";
/**
* @title TellerAS - Teller Attestation Service - based on EAS - Ethereum Attestation Service
*/
contract TellerAS is IEAS {
error AccessDenied();
error AlreadyRevoked();
error InvalidAttestation();
error InvalidExpirationTime();
error InvalidOffset();
error InvalidRegistry();
error InvalidSchema();
error InvalidVerifier();
error NotFound();
error NotPayable();
string public constant VERSION = "0.8";
// A terminator used when concatenating and hashing multiple fields.
string private constant HASH_TERMINATOR = "@";
// The AS global registry.
IASRegistry private immutable _asRegistry;
// The EIP712 verifier used to verify signed attestations.
IEASEIP712Verifier private immutable _eip712Verifier;
// A mapping between attestations and their related attestations.
mapping(bytes32 => bytes32[]) private _relatedAttestations;
// A mapping between an account and its received attestations.
mapping(address => mapping(bytes32 => bytes32[]))
private _receivedAttestations;
// A mapping between an account and its sent attestations.
mapping(address => mapping(bytes32 => bytes32[])) private _sentAttestations;
// A mapping between a schema and its attestations.
mapping(bytes32 => bytes32[]) private _schemaAttestations;
// The global mapping between attestations and their UUIDs.
mapping(bytes32 => Attestation) private _db;
// The global counter for the total number of attestations.
uint256 private _attestationsCount;
bytes32 private _lastUUID;
/**
* @dev Creates a new EAS instance.
*
* @param registry The address of the global AS registry.
* @param verifier The address of the EIP712 verifier.
*/
constructor(IASRegistry registry, IEASEIP712Verifier verifier) {
if (address(registry) == address(0x0)) {
revert InvalidRegistry();
}
if (address(verifier) == address(0x0)) {
revert InvalidVerifier();
}
_asRegistry = registry;
_eip712Verifier = verifier;
}
/**
* @inheritdoc IEAS
*/
function getASRegistry() external view override returns (IASRegistry) {
return _asRegistry;
}
/**
* @inheritdoc IEAS
*/
function getEIP712Verifier()
external
view
override
returns (IEASEIP712Verifier)
{
return _eip712Verifier;
}
/**
* @inheritdoc IEAS
*/
function getAttestationsCount() external view override returns (uint256) {
return _attestationsCount;
}
/**
* @inheritdoc IEAS
*/
function attest(
address recipient,
bytes32 schema,
uint256 expirationTime,
bytes32 refUUID,
bytes calldata data
) public payable virtual override returns (bytes32) {
return
_attest(
recipient,
schema,
expirationTime,
refUUID,
data,
msg.sender
);
}
/**
* @inheritdoc IEAS
*/
function attestByDelegation(
address recipient,
bytes32 schema,
uint256 expirationTime,
bytes32 refUUID,
bytes calldata data,
address attester,
uint8 v,
bytes32 r,
bytes32 s
) public payable virtual override returns (bytes32) {
_eip712Verifier.attest(
recipient,
schema,
expirationTime,
refUUID,
data,
attester,
v,
r,
s
);
return
_attest(recipient, schema, expirationTime, refUUID, data, attester);
}
/**
* @inheritdoc IEAS
*/
function revoke(bytes32 uuid) public virtual override {
return _revoke(uuid, msg.sender);
}
/**
* @inheritdoc IEAS
*/
function revokeByDelegation(
bytes32 uuid,
address attester,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
_eip712Verifier.revoke(uuid, attester, v, r, s);
_revoke(uuid, attester);
}
/**
* @inheritdoc IEAS
*/
function getAttestation(bytes32 uuid)
external
view
override
returns (Attestation memory)
{
return _db[uuid];
}
/**
* @inheritdoc IEAS
*/
function isAttestationValid(bytes32 uuid)
public
view
override
returns (bool)
{
return _db[uuid].uuid != 0;
}
/**
* @inheritdoc IEAS
*/
function isAttestationActive(bytes32 uuid)
public
view
virtual
override
returns (bool)
{
return
isAttestationValid(uuid) &&
_db[uuid].expirationTime >= block.timestamp &&
_db[uuid].revocationTime == 0;
}
/**
* @inheritdoc IEAS
*/
function getReceivedAttestationUUIDs(
address recipient,
bytes32 schema,
uint256 start,
uint256 length,
bool reverseOrder
) external view override returns (bytes32[] memory) {
return
_sliceUUIDs(
_receivedAttestations[recipient][schema],
start,
length,
reverseOrder
);
}
/**
* @inheritdoc IEAS
*/
function getReceivedAttestationUUIDsCount(address recipient, bytes32 schema)
external
view
override
returns (uint256)
{
return _receivedAttestations[recipient][schema].length;
}
/**
* @inheritdoc IEAS
*/
function getSentAttestationUUIDs(
address attester,
bytes32 schema,
uint256 start,
uint256 length,
bool reverseOrder
) external view override returns (bytes32[] memory) {
return
_sliceUUIDs(
_sentAttestations[attester][schema],
start,
length,
reverseOrder
);
}
/**
* @inheritdoc IEAS
*/
function getSentAttestationUUIDsCount(address recipient, bytes32 schema)
external
view
override
returns (uint256)
{
return _sentAttestations[recipient][schema].length;
}
/**
* @inheritdoc IEAS
*/
function getRelatedAttestationUUIDs(
bytes32 uuid,
uint256 start,
uint256 length,
bool reverseOrder
) external view override returns (bytes32[] memory) {
return
_sliceUUIDs(
_relatedAttestations[uuid],
start,
length,
reverseOrder
);
}
/**
* @inheritdoc IEAS
*/
function getRelatedAttestationUUIDsCount(bytes32 uuid)
external
view
override
returns (uint256)
{
return _relatedAttestations[uuid].length;
}
/**
* @inheritdoc IEAS
*/
function getSchemaAttestationUUIDs(
bytes32 schema,
uint256 start,
uint256 length,
bool reverseOrder
) external view override returns (bytes32[] memory) {
return
_sliceUUIDs(
_schemaAttestations[schema],
start,
length,
reverseOrder
);
}
/**
* @inheritdoc IEAS
*/
function getSchemaAttestationUUIDsCount(bytes32 schema)
external
view
override
returns (uint256)
{
return _schemaAttestations[schema].length;
}
/**
* @dev Attests to a specific AS.
*
* @param recipient The recipient of the attestation.
* @param schema The UUID of the AS.
* @param expirationTime The expiration time of the attestation.
* @param refUUID An optional related attestation's UUID.
* @param data Additional custom data.
* @param attester The attesting account.
*
* @return The UUID of the new attestation.
*/
function _attest(
address recipient,
bytes32 schema,
uint256 expirationTime,
bytes32 refUUID,
bytes calldata data,
address attester
) private returns (bytes32) {
if (expirationTime <= block.timestamp) {
revert InvalidExpirationTime();
}
IASRegistry.ASRecord memory asRecord = _asRegistry.getAS(schema);
if (asRecord.uuid == EMPTY_UUID) {
revert InvalidSchema();
}
IASResolver resolver = asRecord.resolver;
if (address(resolver) != address(0x0)) {
if (msg.value != 0 && !resolver.isPayable()) {
revert NotPayable();
}
if (
!resolver.resolve{ value: msg.value }(
recipient,
asRecord.schema,
data,
expirationTime,
attester
)
) {
revert InvalidAttestation();
}
}
Attestation memory attestation = Attestation({
uuid: EMPTY_UUID,
schema: schema,
recipient: recipient,
attester: attester,
time: block.timestamp,
expirationTime: expirationTime,
revocationTime: 0,
refUUID: refUUID,
data: data
});
_lastUUID = _getUUID(attestation);
attestation.uuid = _lastUUID;
_receivedAttestations[recipient][schema].push(_lastUUID);
_sentAttestations[attester][schema].push(_lastUUID);
_schemaAttestations[schema].push(_lastUUID);
_db[_lastUUID] = attestation;
_attestationsCount++;
if (refUUID != 0) {
if (!isAttestationValid(refUUID)) {
revert NotFound();
}
_relatedAttestations[refUUID].push(_lastUUID);
}
emit Attested(recipient, attester, _lastUUID, schema);
return _lastUUID;
}
function getLastUUID() external view returns (bytes32) {
return _lastUUID;
}
/**
* @dev Revokes an existing attestation to a specific AS.
*
* @param uuid The UUID of the attestation to revoke.
* @param attester The attesting account.
*/
function _revoke(bytes32 uuid, address attester) private {
Attestation storage attestation = _db[uuid];
if (attestation.uuid == EMPTY_UUID) {
revert NotFound();
}
if (attestation.attester != attester) {
revert AccessDenied();
}
if (attestation.revocationTime != 0) {
revert AlreadyRevoked();
}
attestation.revocationTime = block.timestamp;
emit Revoked(attestation.recipient, attester, uuid, attestation.schema);
}
/**
* @dev Calculates a UUID for a given attestation.
*
* @param attestation The input attestation.
*
* @return Attestation UUID.
*/
function _getUUID(Attestation memory attestation)
private
view
returns (bytes32)
{
return
keccak256(
abi.encodePacked(
attestation.schema,
attestation.recipient,
attestation.attester,
attestation.time,
attestation.expirationTime,
attestation.data,
HASH_TERMINATOR,
_attestationsCount
)
);
}
/**
* @dev Returns a slice in an array of attestation UUIDs.
*
* @param uuids The array of attestation UUIDs.
* @param start The offset to start from.
* @param length The number of total members to retrieve.
* @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
*
* @return An array of attestation UUIDs.
*/
function _sliceUUIDs(
bytes32[] memory uuids,
uint256 start,
uint256 length,
bool reverseOrder
) private pure returns (bytes32[] memory) {
uint256 attestationsLength = uuids.length;
if (attestationsLength == 0) {
return new bytes32[](0);
}
if (start >= attestationsLength) {
revert InvalidOffset();
}
uint256 len = length;
if (attestationsLength < start + length) {
len = attestationsLength - start;
}
bytes32[] memory res = new bytes32[](len);
for (uint256 i = 0; i < len; ++i) {
res[i] = uuids[
reverseOrder ? attestationsLength - (start + i + 1) : start + i
];
}
return res;
}
}// SPDX-Licence-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
enum CollateralType {
ERC20,
ERC721,
ERC1155
}
struct Collateral {
CollateralType _collateralType;
uint256 _amount;
uint256 _tokenId;
address _collateralAddress;
}
interface ICollateralEscrowV1 {
/**
* @notice Deposits a collateral asset into the escrow.
* @param _collateralType The type of collateral asset to deposit (ERC721, ERC1155).
* @param _collateralAddress The address of the collateral token.i feel
* @param _amount The amount to deposit.
*/
function depositAsset(
CollateralType _collateralType,
address _collateralAddress,
uint256 _amount,
uint256 _tokenId
) external payable;
/**
* @notice Withdraws a collateral asset from the escrow.
* @param _collateralAddress The address of the collateral contract.
* @param _amount The amount to withdraw.
* @param _recipient The address to send the assets to.
*/
function withdraw(
address _collateralAddress,
uint256 _amount,
address _recipient
) external;
function withdrawDustTokens(
address _tokenAddress,
uint256 _amount,
address _recipient
) external;
function getBid() external view returns (uint256);
function initialize(uint256 _bidId) external;
}pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: MIT
import "./IASResolver.sol";
/**
* @title The global AS registry interface.
*/
interface IASRegistry {
/**
* @title A struct representing a record for a submitted AS (Attestation Schema).
*/
struct ASRecord {
// A unique identifier of the AS.
bytes32 uuid;
// Optional schema resolver.
IASResolver resolver;
// Auto-incrementing index for reference, assigned by the registry itself.
uint256 index;
// Custom specification of the AS (e.g., an ABI).
bytes schema;
}
/**
* @dev Triggered when a new AS has been registered
*
* @param uuid The AS UUID.
* @param index The AS index.
* @param schema The AS schema.
* @param resolver An optional AS schema resolver.
* @param attester The address of the account used to register the AS.
*/
event Registered(
bytes32 indexed uuid,
uint256 indexed index,
bytes schema,
IASResolver resolver,
address attester
);
/**
* @dev Submits and reserve a new AS
*
* @param schema The AS data schema.
* @param resolver An optional AS schema resolver.
*
* @return The UUID of the new AS.
*/
function register(bytes calldata schema, IASResolver resolver)
external
returns (bytes32);
/**
* @dev Returns an existing AS by UUID
*
* @param uuid The UUID of the AS to retrieve.
*
* @return The AS data members.
*/
function getAS(bytes32 uuid) external view returns (ASRecord memory);
/**
* @dev Returns the global counter for the total number of attestations
*
* @return The global counter for the total number of attestations.
*/
function getASCount() external view returns (uint256);
}pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: MIT
/**
* @title The interface of an optional AS resolver.
*/
interface IASResolver {
/**
* @dev Returns whether the resolver supports ETH transfers
*/
function isPayable() external pure returns (bool);
/**
* @dev Resolves an attestation and verifier whether its data conforms to the spec.
*
* @param recipient The recipient of the attestation.
* @param schema The AS data schema.
* @param data The actual attestation data.
* @param expirationTime The expiration time of the attestation.
* @param msgSender The sender of the original attestation message.
*
* @return Whether the data is valid according to the scheme.
*/
function resolve(
address recipient,
bytes calldata schema,
bytes calldata data,
uint256 expirationTime,
address msgSender
) external payable returns (bool);
}// SPDX-Licence-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
import { Collateral } from "./escrow/ICollateralEscrowV1.sol";
interface ICollateralManager {
/**
* @notice Checks the validity of a borrower's collateral balance.
* @param _bidId The id of the associated bid.
* @param _collateralInfo Additional information about the collateral asset.
* @return validation_ Boolean indicating if the collateral balance was validated.
*/
function commitCollateral(
uint256 _bidId,
Collateral[] calldata _collateralInfo
) external returns (bool validation_);
/**
* @notice Checks the validity of a borrower's collateral balance and commits it to a bid.
* @param _bidId The id of the associated bid.
* @param _collateralInfo Additional information about the collateral asset.
* @return validation_ Boolean indicating if the collateral balance was validated.
*/
function commitCollateral(
uint256 _bidId,
Collateral calldata _collateralInfo
) external returns (bool validation_);
function checkBalances(
address _borrowerAddress,
Collateral[] calldata _collateralInfo
) external returns (bool validated_, bool[] memory checks_);
/**
* @notice Deploys a new collateral escrow.
* @param _bidId The associated bidId of the collateral escrow.
*/
function deployAndDeposit(uint256 _bidId) external;
/**
* @notice Gets the address of a deployed escrow.
* @notice _bidId The bidId to return the escrow for.
* @return The address of the escrow.
*/
function getEscrow(uint256 _bidId) external view returns (address);
/**
* @notice Gets the collateral info for a given bid id.
* @param _bidId The bidId to return the collateral info for.
* @return The stored collateral info.
*/
function getCollateralInfo(uint256 _bidId)
external
view
returns (Collateral[] memory);
function getCollateralAmount(uint256 _bidId, address collateralAssetAddress)
external
view
returns (uint256 _amount);
/**
* @notice Withdraws deposited collateral from the created escrow of a bid.
* @param _bidId The id of the bid to withdraw collateral for.
*/
function withdraw(uint256 _bidId) external;
/**
* @notice Re-checks the validity of a borrower's collateral balance committed to a bid.
* @param _bidId The id of the associated bid.
* @return validation_ Boolean indicating if the collateral balance was validated.
*/
function revalidateCollateral(uint256 _bidId) external returns (bool);
/**
* @notice Sends the deposited collateral to a lender of a bid.
* @notice Can only be called by the protocol.
* @param _bidId The id of the liquidated bid.
*/
function lenderClaimCollateral(uint256 _bidId) external;
/**
* @notice Sends the deposited collateral to a lender of a bid.
* @notice Can only be called by the protocol.
* @param _bidId The id of the liquidated bid.
* @param _collateralRecipient the address that will receive the collateral
*/
function lenderClaimCollateralWithRecipient(uint256 _bidId, address _collateralRecipient) external;
/**
* @notice Sends the deposited collateral to a liquidator of a bid.
* @notice Can only be called by the protocol.
* @param _bidId The id of the liquidated bid.
* @param _liquidatorAddress The address of the liquidator to send the collateral to.
*/
function liquidateCollateral(uint256 _bidId, address _liquidatorAddress)
external;
}pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: MIT
import "./IASRegistry.sol";
import "./IEASEIP712Verifier.sol";
/**
* @title EAS - Ethereum Attestation Service interface
*/
interface IEAS {
/**
* @dev A struct representing a single attestation.
*/
struct Attestation {
// A unique identifier of the attestation.
bytes32 uuid;
// A unique identifier of the AS.
bytes32 schema;
// The recipient of the attestation.
address recipient;
// The attester/sender of the attestation.
address attester;
// The time when the attestation was created (Unix timestamp).
uint256 time;
// The time when the attestation expires (Unix timestamp).
uint256 expirationTime;
// The time when the attestation was revoked (Unix timestamp).
uint256 revocationTime;
// The UUID of the related attestation.
bytes32 refUUID;
// Custom attestation data.
bytes data;
}
/**
* @dev Triggered when an attestation has been made.
*
* @param recipient The recipient of the attestation.
* @param attester The attesting account.
* @param uuid The UUID the revoked attestation.
* @param schema The UUID of the AS.
*/
event Attested(
address indexed recipient,
address indexed attester,
bytes32 uuid,
bytes32 indexed schema
);
/**
* @dev Triggered when an attestation has been revoked.
*
* @param recipient The recipient of the attestation.
* @param attester The attesting account.
* @param schema The UUID of the AS.
* @param uuid The UUID the revoked attestation.
*/
event Revoked(
address indexed recipient,
address indexed attester,
bytes32 uuid,
bytes32 indexed schema
);
/**
* @dev Returns the address of the AS global registry.
*
* @return The address of the AS global registry.
*/
function getASRegistry() external view returns (IASRegistry);
/**
* @dev Returns the address of the EIP712 verifier used to verify signed attestations.
*
* @return The address of the EIP712 verifier used to verify signed attestations.
*/
function getEIP712Verifier() external view returns (IEASEIP712Verifier);
/**
* @dev Returns the global counter for the total number of attestations.
*
* @return The global counter for the total number of attestations.
*/
function getAttestationsCount() external view returns (uint256);
/**
* @dev Attests to a specific AS.
*
* @param recipient The recipient of the attestation.
* @param schema The UUID of the AS.
* @param expirationTime The expiration time of the attestation.
* @param refUUID An optional related attestation's UUID.
* @param data Additional custom data.
*
* @return The UUID of the new attestation.
*/
function attest(
address recipient,
bytes32 schema,
uint256 expirationTime,
bytes32 refUUID,
bytes calldata data
) external payable returns (bytes32);
/**
* @dev Attests to a specific AS using a provided EIP712 signature.
*
* @param recipient The recipient of the attestation.
* @param schema The UUID of the AS.
* @param expirationTime The expiration time of the attestation.
* @param refUUID An optional related attestation's UUID.
* @param data Additional custom data.
* @param attester The attesting account.
* @param v The recovery ID.
* @param r The x-coordinate of the nonce R.
* @param s The signature data.
*
* @return The UUID of the new attestation.
*/
function attestByDelegation(
address recipient,
bytes32 schema,
uint256 expirationTime,
bytes32 refUUID,
bytes calldata data,
address attester,
uint8 v,
bytes32 r,
bytes32 s
) external payable returns (bytes32);
/**
* @dev Revokes an existing attestation to a specific AS.
*
* @param uuid The UUID of the attestation to revoke.
*/
function revoke(bytes32 uuid) external;
/**
* @dev Attests to a specific AS using a provided EIP712 signature.
*
* @param uuid The UUID of the attestation to revoke.
* @param attester The attesting account.
* @param v The recovery ID.
* @param r The x-coordinate of the nonce R.
* @param s The signature data.
*/
function revokeByDelegation(
bytes32 uuid,
address attester,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns an existing attestation by UUID.
*
* @param uuid The UUID of the attestation to retrieve.
*
* @return The attestation data members.
*/
function getAttestation(bytes32 uuid)
external
view
returns (Attestation memory);
/**
* @dev Checks whether an attestation exists.
*
* @param uuid The UUID of the attestation to retrieve.
*
* @return Whether an attestation exists.
*/
function isAttestationValid(bytes32 uuid) external view returns (bool);
/**
* @dev Checks whether an attestation is active.
*
* @param uuid The UUID of the attestation to retrieve.
*
* @return Whether an attestation is active.
*/
function isAttestationActive(bytes32 uuid) external view returns (bool);
/**
* @dev Returns all received attestation UUIDs.
*
* @param recipient The recipient of the attestation.
* @param schema The UUID of the AS.
* @param start The offset to start from.
* @param length The number of total members to retrieve.
* @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
*
* @return An array of attestation UUIDs.
*/
function getReceivedAttestationUUIDs(
address recipient,
bytes32 schema,
uint256 start,
uint256 length,
bool reverseOrder
) external view returns (bytes32[] memory);
/**
* @dev Returns the number of received attestation UUIDs.
*
* @param recipient The recipient of the attestation.
* @param schema The UUID of the AS.
*
* @return The number of attestations.
*/
function getReceivedAttestationUUIDsCount(address recipient, bytes32 schema)
external
view
returns (uint256);
/**
* @dev Returns all sent attestation UUIDs.
*
* @param attester The attesting account.
* @param schema The UUID of the AS.
* @param start The offset to start from.
* @param length The number of total members to retrieve.
* @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
*
* @return An array of attestation UUIDs.
*/
function getSentAttestationUUIDs(
address attester,
bytes32 schema,
uint256 start,
uint256 length,
bool reverseOrder
) external view returns (bytes32[] memory);
/**
* @dev Returns the number of sent attestation UUIDs.
*
* @param recipient The recipient of the attestation.
* @param schema The UUID of the AS.
*
* @return The number of attestations.
*/
function getSentAttestationUUIDsCount(address recipient, bytes32 schema)
external
view
returns (uint256);
/**
* @dev Returns all attestations related to a specific attestation.
*
* @param uuid The UUID of the attestation to retrieve.
* @param start The offset to start from.
* @param length The number of total members to retrieve.
* @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
*
* @return An array of attestation UUIDs.
*/
function getRelatedAttestationUUIDs(
bytes32 uuid,
uint256 start,
uint256 length,
bool reverseOrder
) external view returns (bytes32[] memory);
/**
* @dev Returns the number of related attestation UUIDs.
*
* @param uuid The UUID of the attestation to retrieve.
*
* @return The number of related attestations.
*/
function getRelatedAttestationUUIDsCount(bytes32 uuid)
external
view
returns (uint256);
/**
* @dev Returns all per-schema attestation UUIDs.
*
* @param schema The UUID of the AS.
* @param start The offset to start from.
* @param length The number of total members to retrieve.
* @param reverseOrder Whether the offset starts from the end and the data is returned in reverse.
*
* @return An array of attestation UUIDs.
*/
function getSchemaAttestationUUIDs(
bytes32 schema,
uint256 start,
uint256 length,
bool reverseOrder
) external view returns (bytes32[] memory);
/**
* @dev Returns the number of per-schema attestation UUIDs.
*
* @param schema The UUID of the AS.
*
* @return The number of attestations.
*/
function getSchemaAttestationUUIDsCount(bytes32 schema)
external
view
returns (uint256);
}pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: MIT
/**
* @title EIP712 typed signatures verifier for EAS delegated attestations interface.
*/
interface IEASEIP712Verifier {
/**
* @dev Returns the current nonce per-account.
*
* @param account The requested accunt.
*
* @return The current nonce.
*/
function getNonce(address account) external view returns (uint256);
/**
* @dev Verifies signed attestation.
*
* @param recipient The recipient of the attestation.
* @param schema The UUID of the AS.
* @param expirationTime The expiration time of the attestation.
* @param refUUID An optional related attestation's UUID.
* @param data Additional custom data.
* @param attester The attesting account.
* @param v The recovery ID.
* @param r The x-coordinate of the nonce R.
* @param s The signature data.
*/
function attest(
address recipient,
bytes32 schema,
uint256 expirationTime,
bytes32 refUUID,
bytes calldata data,
address attester,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Verifies signed revocations.
*
* @param uuid The UUID of the attestation to revoke.
* @param attester The attesting account.
* @param v The recovery ID.
* @param r The x-coordinate of the nonce R.
* @param s The signature data.
*/
function revoke(
bytes32 uuid,
address attester,
uint8 v,
bytes32 r,
bytes32 s
) external;
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
interface IEscrowVault {
/**
* @notice Deposit tokens on behalf of another account
* @param account The address of the account
* @param token The address of the token
* @param amount The amount to increase the balance
*/
function deposit(address account, address token, uint256 amount) external;
function withdraw(address token, uint256 amount) external ;
}// SPDX-Licence-Identifier: MIT
pragma solidity >=0.8.0 <0.9.0;
interface ILenderCommitmentForwarder {
enum CommitmentCollateralType {
NONE, // no collateral required
ERC20,
ERC721,
ERC1155,
ERC721_ANY_ID,
ERC1155_ANY_ID,
ERC721_MERKLE_PROOF,
ERC1155_MERKLE_PROOF
}
/**
* @notice Details about a lender's capital commitment.
* @param maxPrincipal Amount of tokens being committed by the lender. Max amount that can be loaned.
* @param expiration Expiration time in seconds, when the commitment expires.
* @param maxDuration Length of time, in seconds that the lender's capital can be lent out for.
* @param minInterestRate Minimum Annual percentage to be applied for loans using the lender's capital.
* @param collateralTokenAddress The address for the token contract that must be used to provide collateral for loans for this commitment.
* @param maxPrincipalPerCollateralAmount The amount of principal that can be used for a loan per each unit of collateral, expanded additionally by principal decimals.
* @param collateralTokenType The type of asset of the collateralTokenAddress (ERC20, ERC721, or ERC1155).
* @param lender The address of the lender for this commitment.
* @param marketId The market id for this commitment.
* @param principalTokenAddress The address for the token contract that will be used to provide principal for loans of this commitment.
*/
struct Commitment {
uint256 maxPrincipal;
uint32 expiration;
uint32 maxDuration;
uint16 minInterestRate;
address collateralTokenAddress;
uint256 collateralTokenId; //we use this for the MerkleRootHash for type ERC721_MERKLE_PROOF
uint256 maxPrincipalPerCollateralAmount;
CommitmentCollateralType collateralTokenType;
address lender;
uint256 marketId;
address principalTokenAddress;
}
// mapping(uint256 => Commitment) public commitments;
function getCommitmentMarketId(uint256 _commitmentId)
external
view
returns (uint256);
function getCommitmentLender(uint256 _commitmentId)
external
view
returns (address);
function getCommitmentAcceptedPrincipal(uint256 _commitmentId)
external
view
returns (uint256);
function getCommitmentMaxPrincipal(uint256 _commitmentId)
external
view
returns (uint256);
function createCommitment(
Commitment calldata _commitment,
address[] calldata _borrowerAddressList
) external returns (uint256);
function acceptCommitmentWithRecipient(
uint256 _commitmentId,
uint256 _principalAmount,
uint256 _collateralAmount,
uint256 _collateralTokenId,
address _collateralTokenAddress,
address _recipient,
uint16 _interestRate,
uint32 _loanDuration
) external returns (uint256 bidId_);
function acceptCommitmentWithRecipientAndProof(
uint256 _commitmentId,
uint256 _principalAmount,
uint256 _collateralAmount,
uint256 _collateralTokenId,
address _collateralTokenAddress,
address _recipient,
uint16 _interestRate,
uint32 _loanDuration,
bytes32[] calldata _merkleProof
) external returns (uint256 bidId_);
}pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: MIT
import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
abstract contract ILenderManager is IERC721Upgradeable {
/**
* @notice Registers a new active lender for a loan, minting the nft.
* @param _bidId The id for the loan to set.
* @param _newLender The address of the new active lender.
*/
function registerLoan(uint256 _bidId, address _newLender) external virtual;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../EAS/TellerAS.sol";
import { PaymentType, PaymentCycleType } from "../libraries/V2Calculations.sol";
interface IMarketRegistry {
function initialize(TellerAS tellerAs) external;
function isVerifiedLender(uint256 _marketId, address _lender)
external
view
returns (bool, bytes32);
function isMarketOpen(uint256 _marketId) external view returns (bool);
function isMarketClosed(uint256 _marketId) external view returns (bool);
function isVerifiedBorrower(uint256 _marketId, address _borrower)
external
view
returns (bool, bytes32);
function getMarketOwner(uint256 _marketId) external view returns (address);
function getMarketFeeRecipient(uint256 _marketId)
external
view
returns (address);
function getMarketURI(uint256 _marketId)
external
view
returns (string memory);
function getPaymentCycle(uint256 _marketId)
external
view
returns (uint32, PaymentCycleType);
function getPaymentDefaultDuration(uint256 _marketId)
external
view
returns (uint32);
function getBidExpirationTime(uint256 _marketId)
external
view
returns (uint32);
function getMarketplaceFee(uint256 _marketId)
external
view
returns (uint16);
function getPaymentType(uint256 _marketId)
external
view
returns (PaymentType);
function createMarket(
address _initialOwner,
uint32 _paymentCycleDuration,
uint32 _paymentDefaultDuration,
uint32 _bidExpirationTime,
uint16 _feePercent,
bool _requireLenderAttestation,
bool _requireBorrowerAttestation,
PaymentType _paymentType,
PaymentCycleType _paymentCycleType,
string calldata _uri
) external returns (uint256 marketId_);
function createMarket(
address _initialOwner,
uint32 _paymentCycleDuration,
uint32 _paymentDefaultDuration,
uint32 _bidExpirationTime,
uint16 _feePercent,
bool _requireLenderAttestation,
bool _requireBorrowerAttestation,
string calldata _uri
) external returns (uint256 marketId_);
function closeMarket(uint256 _marketId) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
enum RepMark {
Good,
Delinquent,
Default
}
interface IReputationManager {
function initialize(address protocolAddress) external;
function getDelinquentLoanIds(address _account)
external
returns (uint256[] memory);
function getDefaultedLoanIds(address _account)
external
returns (uint256[] memory);
function getCurrentDelinquentLoanIds(address _account)
external
returns (uint256[] memory);
function getCurrentDefaultLoanIds(address _account)
external
returns (uint256[] memory);
function updateAccountReputation(address _account) external;
function updateAccountReputation(address _account, uint256 _bidId)
external
returns (RepMark);
}pragma solidity >=0.8.0 <0.9.0;
interface ISmartCommitmentForwarder {
function acceptSmartCommitmentWithRecipient(
address _smartCommitmentAddress,
uint256 _principalAmount,
uint256 _collateralAmount,
uint256 _collateralTokenId,
address _collateralTokenAddress,
address _recipient,
uint16 _interestRate,
uint32 _loanDuration
) external returns (uint256 bidId) ;
function setLiquidationProtocolFeePercent(uint256 _percent)
external;
function getLiquidationProtocolFeePercent()
external view returns (uint256) ;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { Payment, BidState } from "../TellerV2Storage.sol";
import { Collateral } from "./escrow/ICollateralEscrowV1.sol";
interface ITellerV2 {
/**
* @notice Function for a borrower to create a bid for a loan.
* @param _lendingToken The lending token asset requested to be borrowed.
* @param _marketplaceId The unique id of the marketplace for the bid.
* @param _principal The principal amount of the loan bid.
* @param _duration The recurrent length of time before which a payment is due.
* @param _APR The proposed interest rate for the loan bid.
* @param _metadataURI The URI for additional borrower loan information as part of loan bid.
* @param _receiver The address where the loan amount will be sent to.
*/
function submitBid(
address _lendingToken,
uint256 _marketplaceId,
uint256 _principal,
uint32 _duration,
uint16 _APR,
string calldata _metadataURI,
address _receiver
) external returns (uint256 bidId_);
/**
* @notice Function for a borrower to create a bid for a loan with Collateral.
* @param _lendingToken The lending token asset requested to be borrowed.
* @param _marketplaceId The unique id of the marketplace for the bid.
* @param _principal The principal amount of the loan bid.
* @param _duration The recurrent length of time before which a payment is due.
* @param _APR The proposed interest rate for the loan bid.
* @param _metadataURI The URI for additional borrower loan information as part of loan bid.
* @param _receiver The address where the loan amount will be sent to.
* @param _collateralInfo Additional information about the collateral asset.
*/
function submitBid(
address _lendingToken,
uint256 _marketplaceId,
uint256 _principal,
uint32 _duration,
uint16 _APR,
string calldata _metadataURI,
address _receiver,
Collateral[] calldata _collateralInfo
) external returns (uint256 bidId_);
/**
* @notice Function for a lender to accept a proposed loan bid.
* @param _bidId The id of the loan bid to accept.
*/
function lenderAcceptBid(uint256 _bidId)
external
returns (
uint256 amountToProtocol,
uint256 amountToMarketplace,
uint256 amountToBorrower
);
/**
* @notice Function for users to make the minimum amount due for an active loan.
* @param _bidId The id of the loan to make the payment towards.
*/
function repayLoanMinimum(uint256 _bidId) external;
/**
* @notice Function for users to repay an active loan in full.
* @param _bidId The id of the loan to make the payment towards.
*/
function repayLoanFull(uint256 _bidId) external;
/**
* @notice Function for users to make a payment towards an active loan.
* @param _bidId The id of the loan to make the payment towards.
* @param _amount The amount of the payment.
*/
function repayLoan(uint256 _bidId, uint256 _amount) external;
/**
* @notice Checks to see if a borrower is delinquent.
* @param _bidId The id of the loan bid to check for.
*/
function isLoanDefaulted(uint256 _bidId) external view returns (bool);
/**
* @notice Checks to see if a loan was delinquent for longer than liquidation delay.
* @param _bidId The id of the loan bid to check for.
*/
function isLoanLiquidateable(uint256 _bidId) external view returns (bool);
/**
* @notice Checks to see if a borrower is delinquent.
* @param _bidId The id of the loan bid to check for.
*/
function isPaymentLate(uint256 _bidId) external view returns (bool);
function getBidState(uint256 _bidId) external view returns (BidState);
function getBorrowerActiveLoanIds(address _borrower)
external
view
returns (uint256[] memory);
/**
* @notice Returns the borrower address for a given bid.
* @param _bidId The id of the bid/loan to get the borrower for.
* @return borrower_ The address of the borrower associated with the bid.
*/
function getLoanBorrower(uint256 _bidId)
external
view
returns (address borrower_);
/**
* @notice Returns the lender address for a given bid.
* @param _bidId The id of the bid/loan to get the lender for.
* @return lender_ The address of the lender associated with the bid.
*/
function getLoanLender(uint256 _bidId)
external
view
returns (address lender_);
function getLoanLendingToken(uint256 _bidId)
external
view
returns (address token_);
function getLoanMarketId(uint256 _bidId) external view returns (uint256);
function getLoanSummary(uint256 _bidId)
external
view
returns (
address borrower,
address lender,
uint256 marketId,
address principalTokenAddress,
uint256 principalAmount,
uint32 acceptedTimestamp,
uint32 lastRepaidTimestamp,
BidState bidState
);
function calculateAmountOwed(uint256 _bidId, uint256 _timestamp)
external
view
returns (Payment memory owed);
function calculateAmountDue(uint256 _bidId, uint256 _timestamp)
external
view
returns (Payment memory due);
function lenderCloseLoan(uint256 _bidId) external;
function lenderCloseLoanWithRecipient(uint256 _bidId, address _recipient)
external;
function liquidateLoanFull(uint256 _bidId) external;
function liquidateLoanFullWithRecipient(uint256 _bidId, address _recipient)
external;
function getLoanDefaultTimestamp(uint256 _bidId)
external
view
returns (uint256);
function getEscrowVault() external view returns(address);
function getProtocolFeeRecipient () external view returns(address);
// function isPauser(address _account) external view returns(bool);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface ITellerV2Storage {
function marketRegistry() external view returns (address);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Contracts
import "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// Interfaces
import "../../../interfaces/ITellerV2.sol";
import "../../../interfaces/ITellerV2Storage.sol";
import "../../../interfaces/IMarketRegistry.sol";
import "../../../interfaces/ILenderCommitmentForwarder.sol";
import "../../../interfaces/ISmartCommitmentForwarder.sol";
import '../../../libraries/uniswap/periphery/libraries/TransferHelper.sol';
import '../../../libraries/uniswap/periphery/interfaces/ISwapRouter02.sol';
import '../../../libraries/uniswap/periphery/interfaces/IQuoter.sol';
/*
A one-tx strategy to borrow funds and then immediately swap them using uniswap
*/
contract BorrowSwap_G3 {
using AddressUpgradeable for address;
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable
ITellerV2 public immutable TELLER_V2;
ISwapRouter02 public immutable UNISWAP_SWAP_ROUTER;
IQuoter public immutable UNISWAP_QUOTER;
event BorrowSwapComplete(
address borrower,
uint256 loanId,
address token0 ,
uint256 amountIn,
uint256 amountOut
);
struct AcceptCommitmentArgs {
uint256 commitmentId;
address smartCommitmentAddress; //if this is not address(0), we will use this ! leave empty if not used.
uint256 principalAmount;
uint256 collateralAmount;
uint256 collateralTokenId;
address collateralTokenAddress;
uint16 interestRate;
uint32 loanDuration;
bytes32[] merkleProof; //empty array if not used
}
struct TokenSwapPath {
uint24 poolFee ;
address tokenOut ;
}
struct SwapArgs {
TokenSwapPath[] swapPaths ; //used to build the bytes path
uint160 amountOutMinimum;
}
/**
* @param _tellerV2 The address of the TellerV2 contract.
* @param _swapRouter The address of the UniswapV3 SwapRouter_02
* @param quoter The address of the UniswapV3 Quoter
*/
/// @custom:oz-upgrades-unsafe-allow constructor
constructor(
address _tellerV2,
address _swapRouter, //swapRouter02
address _quoter //quoter
) {
TELLER_V2 = ITellerV2(_tellerV2);
UNISWAP_SWAP_ROUTER = ISwapRouter02( _swapRouter );
UNISWAP_QUOTER = IQuoter( _quoter );
}
/**
* @notice Borrows funds from a lender commitment and immediately swaps them through Uniswap V3.
* @dev This function accepts a loan commitment, receives principal tokens, and swaps them
* for another token using Uniswap V3. The swapped tokens are sent to the borrower.
* Additional input tokens can be provided to increase the swap amount.
*
* @param _lenderCommitmentForwarder The address of the lender commitment forwarder contract
* @param _principalToken The address of the token being borrowed (input token for swap)
* @param _additionalInputAmount Additional amount of principal token to add to the swap
* @param _swapArgs Struct containing swap parameters including paths and minimum output
* @param _acceptCommitmentArgs Struct containing loan commitment acceptance parameters
*
* @dev Emits BorrowSwapComplete event upon successful execution
* @dev Requires borrower to have approved this contract for _additionalInputAmount if > 0
*/
function borrowSwap(
address _lenderCommitmentForwarder,
address _principalToken ,
uint256 _additionalInputAmount, //an additional amount
SwapArgs calldata _swapArgs,
AcceptCommitmentArgs calldata _acceptCommitmentArgs
) external {
address borrower = msg.sender ;
if (_additionalInputAmount > 0) {
TransferHelper.safeTransferFrom(_principalToken, borrower, address(this), _additionalInputAmount);
}
// Accept commitment, lock up collateral, receive funds to this contract -- the principal
(uint256 newLoanId, uint256 acceptCommitmentAmount) = _acceptCommitment(
_lenderCommitmentForwarder,
borrower,
_principalToken,
_acceptCommitmentArgs
);
uint256 totalInputAmount = acceptCommitmentAmount + _additionalInputAmount ;
// Approve the router to spend DAI.
TransferHelper.safeApprove( _principalToken , address(UNISWAP_SWAP_ROUTER), totalInputAmount);
// Multiple pool swaps are encoded through bytes called a `path`. A path is a sequence of token addresses and poolFees that define the pools used in the swaps.
// The format for pool encoding is (tokenIn, fee, tokenOut/tokenIn, fee, tokenOut) where tokenIn/tokenOut parameter is the shared token across the pools.
// Since we are swapping DAI to USDC and then USDC to WETH9 the path encoding is (DAI, 0.3%, USDC, 0.3%, WETH9).
ISwapRouter02.ExactInputParams memory swapParams =
ISwapRouter02.ExactInputParams({
path: generateSwapPath( _principalToken, _swapArgs.swapPaths ) ,//path: abi.encodePacked(DAI, poolFee, USDC, poolFee, WETH9),
recipient: address( borrower ) ,
// deadline: _swapArgs.deadline,
amountIn: totalInputAmount ,
amountOutMinimum: _swapArgs.amountOutMinimum //can be 0 for testing -- get from IQuoter
});
// Executes the swap.
uint256 swapAmountOut = UNISWAP_SWAP_ROUTER.exactInput( swapParams );
emit BorrowSwapComplete(
borrower,
newLoanId,
_principalToken ,
totalInputAmount ,
swapAmountOut
);
}
/**
* @notice Generates a Uniswap V3 swap path from input token and swap path array.
* @dev Encodes token addresses and pool fees into bytes format required by Uniswap V3.
* Supports single-hop (1 path) and double-hop (2 paths) swaps only.
*
* @param inputToken The address of the input token (starting token of the swap)
* @param swapPaths Array of TokenSwapPath structs containing tokenOut and poolFee for each hop
*
* @return bytes The encoded swap path compatible with Uniswap V3 router
*
* @dev Reverts with "invalid swap path length" if swapPaths length is not 1 or 2
* @dev For single hop: encodes (inputToken, poolFee, tokenOut)
* @dev For double hop: encodes (inputToken, poolFee1, tokenOut1, poolFee2, tokenOut2)
*/
function generateSwapPath(
address inputToken,
TokenSwapPath[] calldata swapPaths
) public view returns (bytes memory) {
if (swapPaths.length == 1 ){
return abi.encodePacked(inputToken, swapPaths[0].poolFee, swapPaths[0].tokenOut ) ;
}else if (swapPaths.length == 2 ){
return abi.encodePacked(inputToken, swapPaths[0].poolFee, swapPaths[0].tokenOut, swapPaths[1].poolFee, swapPaths[1].tokenOut ) ;
}else {
revert("invalid swap path length");
}
}
/**
* @notice Quotes the expected output amount for an exact input swap through Uniswap V3.
* @dev Uses Uniswap V3 Quoter to simulate a swap and return expected output without executing.
* This is a view function that doesn't modify state or execute any swaps.
*
* @param inputToken The address of the input token
* @param amountIn The exact amount of input tokens to be swapped
* @param swapPaths Array of TokenSwapPath structs defining the swap route
*
* @return amountOut The expected amount of output tokens from the swap
*
* @dev Uses generateSwapPath internally to create the swap path
* @dev Returns only the amountOut from the quoter, ignoring other returned values
*/
function quoteExactInput (
address inputToken,
uint256 amountIn,
TokenSwapPath[] calldata swapPaths
) external view returns (uint256 amountOut) {
(amountOut, , , ) = UNISWAP_QUOTER.quoteExactInput(
generateSwapPath(inputToken,swapPaths),
amountIn
);
}
/**
*
*
* @notice Accepts a loan commitment using either a Merkle proof or standard method.
*
* @dev The function first checks if a Merkle proof is provided, based on which it calls the relevant
* `acceptCommitment` function in the LenderCommitmentForwarder contract.
*
* @param borrower The address of the borrower for whom the commitment is being accepted.
* @param principalToken The token in which the loan is being accepted.
* @param _commitmentArgs The arguments necessary for accepting the commitment.
*
* @return bidId_ Identifier of the accepted loan.
* @return acceptCommitmentAmount_ The amount received from accepting the commitment.
*/
function _acceptCommitment(
address lenderCommitmentForwarder,
address borrower,
address principalToken,
AcceptCommitmentArgs memory _commitmentArgs
)
internal
virtual
returns (uint256 bidId_, uint256 acceptCommitmentAmount_)
{
uint256 fundsBeforeAcceptCommitment = IERC20Upgradeable(principalToken)
.balanceOf(address(this));
if (_commitmentArgs.smartCommitmentAddress != address(0)) {
bytes memory responseData = address(lenderCommitmentForwarder)
.functionCall(
abi.encodePacked(
abi.encodeWithSelector(
ISmartCommitmentForwarder
.acceptSmartCommitmentWithRecipient
.selector,
_commitmentArgs.smartCommitmentAddress,
_commitmentArgs.principalAmount,
_commitmentArgs.collateralAmount,
_commitmentArgs.collateralTokenId,
_commitmentArgs.collateralTokenAddress,
address(this),
_commitmentArgs.interestRate,
_commitmentArgs.loanDuration
),
borrower //cant be msg.sender because of the flash flow
)
);
(bidId_) = abi.decode(responseData, (uint256));
}else {
bool usingMerkleProof = _commitmentArgs.merkleProof.length > 0;
if (usingMerkleProof) {
bytes memory responseData = address(lenderCommitmentForwarder)
.functionCall(
abi.encodePacked(
abi.encodeWithSelector(
ILenderCommitmentForwarder
.acceptCommitmentWithRecipientAndProof
.selector,
_commitmentArgs.commitmentId,
_commitmentArgs.principalAmount,
_commitmentArgs.collateralAmount,
_commitmentArgs.collateralTokenId,
_commitmentArgs.collateralTokenAddress,
address(this),
_commitmentArgs.interestRate,
_commitmentArgs.loanDuration,
_commitmentArgs.merkleProof
),
borrower //cant be msg.sender because of the flash flow
)
);
(bidId_) = abi.decode(responseData, (uint256));
} else {
bytes memory responseData = address(lenderCommitmentForwarder)
.functionCall(
abi.encodePacked(
abi.encodeWithSelector(
ILenderCommitmentForwarder
.acceptCommitmentWithRecipient
.selector,
_commitmentArgs.commitmentId,
_commitmentArgs.principalAmount,
_commitmentArgs.collateralAmount,
_commitmentArgs.collateralTokenId,
_commitmentArgs.collateralTokenAddress,
address(this),
_commitmentArgs.interestRate,
_commitmentArgs.loanDuration
),
borrower //cant be msg.sender because of the flash flow
)
);
(bidId_) = abi.decode(responseData, (uint256));
}
}
uint256 fundsAfterAcceptCommitment = IERC20Upgradeable(principalToken)
.balanceOf(address(this));
acceptCommitmentAmount_ =
fundsAfterAcceptCommitment -
fundsBeforeAcceptCommitment;
}
function getMarketIdForCommitment(
address _lenderCommitmentForwarder,
uint256 _commitmentId
) external view returns (uint256) {
return _getMarketIdForCommitment(_lenderCommitmentForwarder, _commitmentId);
}
function getMarketFeePct(
uint256 _marketId
) external view returns (uint16) {
return _getMarketFeePct(_marketId);
}
/**
* @notice Retrieves the market ID associated with a given commitment.
* @param _commitmentId The ID of the commitment for which to fetch the market ID.
* @return The ID of the market associated with the provided commitment.
*/
function _getMarketIdForCommitment(address _lenderCommitmentForwarder, uint256 _commitmentId)
internal
view
returns (uint256)
{
return ILenderCommitmentForwarder(_lenderCommitmentForwarder).getCommitmentMarketId(_commitmentId);
}
/**
* @notice Fetches the marketplace fee percentage for a given market ID.
* @param _marketId The ID of the market for which to fetch the fee percentage.
* @return The marketplace fee percentage for the provided market ID.
*/
function _getMarketFeePct(uint256 _marketId)
internal
view
returns (uint16)
{
address _marketRegistryAddress = ITellerV2Storage(address(TELLER_V2))
.marketRegistry();
return
IMarketRegistry(_marketRegistryAddress).getMarketplaceFee(
_marketId
);
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
// ----------------------------------------------------------------------------
// BokkyPooBah's DateTime Library v1.01
//
// A gas-efficient Solidity date and time library
//
// https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary
//
// Tested date range 1970/01/01 to 2345/12/31
//
// Conventions:
// Unit | Range | Notes
// :-------- |:-------------:|:-----
// timestamp | >= 0 | Unix timestamp, number of seconds since 1970/01/01 00:00:00 UTC
// year | 1970 ... 2345 |
// month | 1 ... 12 |
// day | 1 ... 31 |
// hour | 0 ... 23 |
// minute | 0 ... 59 |
// second | 0 ... 59 |
// dayOfWeek | 1 ... 7 | 1 = Monday, ..., 7 = Sunday
//
//
// Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2018-2019. The MIT Licence.
// ----------------------------------------------------------------------------
library BokkyPooBahsDateTimeLibrary {
uint constant SECONDS_PER_DAY = 24 * 60 * 60;
uint constant SECONDS_PER_HOUR = 60 * 60;
uint constant SECONDS_PER_MINUTE = 60;
int constant OFFSET19700101 = 2440588;
uint constant DOW_MON = 1;
uint constant DOW_TUE = 2;
uint constant DOW_WED = 3;
uint constant DOW_THU = 4;
uint constant DOW_FRI = 5;
uint constant DOW_SAT = 6;
uint constant DOW_SUN = 7;
// ------------------------------------------------------------------------
// Calculate the number of days from 1970/01/01 to year/month/day using
// the date conversion algorithm from
// https://aa.usno.navy.mil/faq/JD_formula.html
// and subtracting the offset 2440588 so that 1970/01/01 is day 0
//
// days = day
// - 32075
// + 1461 * (year + 4800 + (month - 14) / 12) / 4
// + 367 * (month - 2 - (month - 14) / 12 * 12) / 12
// - 3 * ((year + 4900 + (month - 14) / 12) / 100) / 4
// - offset
// ------------------------------------------------------------------------
function _daysFromDate(uint year, uint month, uint day)
internal
pure
returns (uint _days)
{
require(year >= 1970);
int _year = int(year);
int _month = int(month);
int _day = int(day);
int __days = _day -
32075 +
(1461 * (_year + 4800 + (_month - 14) / 12)) /
4 +
(367 * (_month - 2 - ((_month - 14) / 12) * 12)) /
12 -
(3 * ((_year + 4900 + (_month - 14) / 12) / 100)) /
4 -
OFFSET19700101;
_days = uint(__days);
}
// ------------------------------------------------------------------------
// Calculate year/month/day from the number of days since 1970/01/01 using
// the date conversion algorithm from
// http://aa.usno.navy.mil/faq/docs/JD_Formula.php
// and adding the offset 2440588 so that 1970/01/01 is day 0
//
// int L = days + 68569 + offset
// int N = 4 * L / 146097
// L = L - (146097 * N + 3) / 4
// year = 4000 * (L + 1) / 1461001
// L = L - 1461 * year / 4 + 31
// month = 80 * L / 2447
// dd = L - 2447 * month / 80
// L = month / 11
// month = month + 2 - 12 * L
// year = 100 * (N - 49) + year + L
// ------------------------------------------------------------------------
function _daysToDate(uint _days)
internal
pure
returns (uint year, uint month, uint day)
{
int __days = int(_days);
int L = __days + 68569 + OFFSET19700101;
int N = (4 * L) / 146097;
L = L - (146097 * N + 3) / 4;
int _year = (4000 * (L + 1)) / 1461001;
L = L - (1461 * _year) / 4 + 31;
int _month = (80 * L) / 2447;
int _day = L - (2447 * _month) / 80;
L = _month / 11;
_month = _month + 2 - 12 * L;
_year = 100 * (N - 49) + _year + L;
year = uint(_year);
month = uint(_month);
day = uint(_day);
}
function timestampFromDate(uint year, uint month, uint day)
internal
pure
returns (uint timestamp)
{
timestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY;
}
function timestampFromDateTime(
uint year,
uint month,
uint day,
uint hour,
uint minute,
uint second
) internal pure returns (uint timestamp) {
timestamp =
_daysFromDate(year, month, day) *
SECONDS_PER_DAY +
hour *
SECONDS_PER_HOUR +
minute *
SECONDS_PER_MINUTE +
second;
}
function timestampToDate(uint timestamp)
internal
pure
returns (uint year, uint month, uint day)
{
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function timestampToDateTime(uint timestamp)
internal
pure
returns (
uint year,
uint month,
uint day,
uint hour,
uint minute,
uint second
)
{
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
uint secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
secs = secs % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
second = secs % SECONDS_PER_MINUTE;
}
function isValidDate(uint year, uint month, uint day)
internal
pure
returns (bool valid)
{
if (year >= 1970 && month > 0 && month <= 12) {
uint daysInMonth = _getDaysInMonth(year, month);
if (day > 0 && day <= daysInMonth) {
valid = true;
}
}
}
function isValidDateTime(
uint year,
uint month,
uint day,
uint hour,
uint minute,
uint second
) internal pure returns (bool valid) {
if (isValidDate(year, month, day)) {
if (hour < 24 && minute < 60 && second < 60) {
valid = true;
}
}
}
function isLeapYear(uint timestamp) internal pure returns (bool leapYear) {
(uint year, , ) = _daysToDate(timestamp / SECONDS_PER_DAY);
leapYear = _isLeapYear(year);
}
function _isLeapYear(uint year) internal pure returns (bool leapYear) {
leapYear = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
function isWeekDay(uint timestamp) internal pure returns (bool weekDay) {
weekDay = getDayOfWeek(timestamp) <= DOW_FRI;
}
function isWeekEnd(uint timestamp) internal pure returns (bool weekEnd) {
weekEnd = getDayOfWeek(timestamp) >= DOW_SAT;
}
function getDaysInMonth(uint timestamp)
internal
pure
returns (uint daysInMonth)
{
(uint year, uint month, ) = _daysToDate(timestamp / SECONDS_PER_DAY);
daysInMonth = _getDaysInMonth(year, month);
}
function _getDaysInMonth(uint year, uint month)
internal
pure
returns (uint daysInMonth)
{
if (
month == 1 ||
month == 3 ||
month == 5 ||
month == 7 ||
month == 8 ||
month == 10 ||
month == 12
) {
daysInMonth = 31;
} else if (month != 2) {
daysInMonth = 30;
} else {
daysInMonth = _isLeapYear(year) ? 29 : 28;
}
}
// 1 = Monday, 7 = Sunday
function getDayOfWeek(uint timestamp)
internal
pure
returns (uint dayOfWeek)
{
uint _days = timestamp / SECONDS_PER_DAY;
dayOfWeek = ((_days + 3) % 7) + 1;
}
function getYear(uint timestamp) internal pure returns (uint year) {
(year, , ) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getMonth(uint timestamp) internal pure returns (uint month) {
(, month, ) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getDay(uint timestamp) internal pure returns (uint day) {
(, , day) = _daysToDate(timestamp / SECONDS_PER_DAY);
}
function getHour(uint timestamp) internal pure returns (uint hour) {
uint secs = timestamp % SECONDS_PER_DAY;
hour = secs / SECONDS_PER_HOUR;
}
function getMinute(uint timestamp) internal pure returns (uint minute) {
uint secs = timestamp % SECONDS_PER_HOUR;
minute = secs / SECONDS_PER_MINUTE;
}
function getSecond(uint timestamp) internal pure returns (uint second) {
second = timestamp % SECONDS_PER_MINUTE;
}
function addYears(uint timestamp, uint _years)
internal
pure
returns (uint newTimestamp)
{
(uint year, uint month, uint day) = _daysToDate(
timestamp / SECONDS_PER_DAY
);
year += _years;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp =
_daysFromDate(year, month, day) *
SECONDS_PER_DAY +
(timestamp % SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addMonths(uint timestamp, uint _months)
internal
pure
returns (uint newTimestamp)
{
(uint year, uint month, uint day) = _daysToDate(
timestamp / SECONDS_PER_DAY
);
month += _months;
year += (month - 1) / 12;
month = ((month - 1) % 12) + 1;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp =
_daysFromDate(year, month, day) *
SECONDS_PER_DAY +
(timestamp % SECONDS_PER_DAY);
require(newTimestamp >= timestamp);
}
function addDays(uint timestamp, uint _days)
internal
pure
returns (uint newTimestamp)
{
newTimestamp = timestamp + _days * SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
function addHours(uint timestamp, uint _hours)
internal
pure
returns (uint newTimestamp)
{
newTimestamp = timestamp + _hours * SECONDS_PER_HOUR;
require(newTimestamp >= timestamp);
}
function addMinutes(uint timestamp, uint _minutes)
internal
pure
returns (uint newTimestamp)
{
newTimestamp = timestamp + _minutes * SECONDS_PER_MINUTE;
require(newTimestamp >= timestamp);
}
function addSeconds(uint timestamp, uint _seconds)
internal
pure
returns (uint newTimestamp)
{
newTimestamp = timestamp + _seconds;
require(newTimestamp >= timestamp);
}
function subYears(uint timestamp, uint _years)
internal
pure
returns (uint newTimestamp)
{
(uint year, uint month, uint day) = _daysToDate(
timestamp / SECONDS_PER_DAY
);
year -= _years;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp =
_daysFromDate(year, month, day) *
SECONDS_PER_DAY +
(timestamp % SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subMonths(uint timestamp, uint _months)
internal
pure
returns (uint newTimestamp)
{
(uint year, uint month, uint day) = _daysToDate(
timestamp / SECONDS_PER_DAY
);
uint yearMonth = year * 12 + (month - 1) - _months;
year = yearMonth / 12;
month = (yearMonth % 12) + 1;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp =
_daysFromDate(year, month, day) *
SECONDS_PER_DAY +
(timestamp % SECONDS_PER_DAY);
require(newTimestamp <= timestamp);
}
function subDays(uint timestamp, uint _days)
internal
pure
returns (uint newTimestamp)
{
newTimestamp = timestamp - _days * SECONDS_PER_DAY;
require(newTimestamp <= timestamp);
}
function subHours(uint timestamp, uint _hours)
internal
pure
returns (uint newTimestamp)
{
newTimestamp = timestamp - _hours * SECONDS_PER_HOUR;
require(newTimestamp <= timestamp);
}
function subMinutes(uint timestamp, uint _minutes)
internal
pure
returns (uint newTimestamp)
{
newTimestamp = timestamp - _minutes * SECONDS_PER_MINUTE;
require(newTimestamp <= timestamp);
}
function subSeconds(uint timestamp, uint _seconds)
internal
pure
returns (uint newTimestamp)
{
newTimestamp = timestamp - _seconds;
require(newTimestamp <= timestamp);
}
function diffYears(uint fromTimestamp, uint toTimestamp)
internal
pure
returns (uint _years)
{
require(fromTimestamp <= toTimestamp);
(uint fromYear, , ) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(uint toYear, , ) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_years = toYear - fromYear;
}
function diffMonths(uint fromTimestamp, uint toTimestamp)
internal
pure
returns (uint _months)
{
require(fromTimestamp <= toTimestamp);
(uint fromYear, uint fromMonth, ) = _daysToDate(
fromTimestamp / SECONDS_PER_DAY
);
(uint toYear, uint toMonth, ) = _daysToDate(
toTimestamp / SECONDS_PER_DAY
);
_months = toYear * 12 + toMonth - fromYear * 12 - fromMonth;
}
function diffDays(uint fromTimestamp, uint toTimestamp)
internal
pure
returns (uint _days)
{
require(fromTimestamp <= toTimestamp);
_days = (toTimestamp - fromTimestamp) / SECONDS_PER_DAY;
}
function diffHours(uint fromTimestamp, uint toTimestamp)
internal
pure
returns (uint _hours)
{
require(fromTimestamp <= toTimestamp);
_hours = (toTimestamp - fromTimestamp) / SECONDS_PER_HOUR;
}
function diffMinutes(uint fromTimestamp, uint toTimestamp)
internal
pure
returns (uint _minutes)
{
require(fromTimestamp <= toTimestamp);
_minutes = (toTimestamp - fromTimestamp) / SECONDS_PER_MINUTE;
}
function diffSeconds(uint fromTimestamp, uint toTimestamp)
internal
pure
returns (uint _seconds)
{
require(fromTimestamp <= toTimestamp);
_seconds = toTimestamp - fromTimestamp;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// Libraries
import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
import "./WadRayMath.sol";
/**
* @dev Utility library for uint256 numbers
*
* @author [email protected]
*/
library NumbersLib {
using WadRayMath for uint256;
/**
* @dev It represents 100% with 2 decimal places.
*/
uint16 internal constant PCT_100 = 10000;
function percentFactor(uint256 decimals) internal pure returns (uint256) {
return 100 * (10**decimals);
}
/**
* @notice Returns a percentage value of a number.
* @param self The number to get a percentage of.
* @param percentage The percentage value to calculate with 2 decimal places (10000 = 100%).
*/
function percent(uint256 self, uint16 percentage)
internal
pure
returns (uint256)
{
return percent(self, percentage, 2);
}
/**
* @notice Returns a percentage value of a number.
* @param self The number to get a percentage of.
* @param percentage The percentage value to calculate with.
* @param decimals The number of decimals the percentage value is in.
*/
function percent(uint256 self, uint256 percentage, uint256 decimals)
internal
pure
returns (uint256)
{
return (self * percentage) / percentFactor(decimals);
}
/**
* @notice it returns the absolute number of a specified parameter
* @param self the number to be returned in it's absolute
* @return the absolute number
*/
function abs(int256 self) internal pure returns (uint256) {
return self >= 0 ? uint256(self) : uint256(-1 * self);
}
/**
* @notice Returns a ratio percentage of {num1} to {num2}.
* @dev Returned value is type uint16.
* @param num1 The number used to get the ratio for.
* @param num2 The number used to get the ratio from.
* @return Ratio percentage with 2 decimal places (10000 = 100%).
*/
function ratioOf(uint256 num1, uint256 num2)
internal
pure
returns (uint16)
{
return SafeCast.toUint16(ratioOf(num1, num2, 2));
}
/**
* @notice Returns a ratio percentage of {num1} to {num2}.
* @param num1 The number used to get the ratio for.
* @param num2 The number used to get the ratio from.
* @param decimals The number of decimals the percentage value is returned in.
* @return Ratio percentage value.
*/
function ratioOf(uint256 num1, uint256 num2, uint256 decimals)
internal
pure
returns (uint256)
{
if (num2 == 0) return 0;
return (num1 * percentFactor(decimals)) / num2;
}
/**
* @notice Calculates the payment amount for a cycle duration.
* The formula is calculated based on the standard Estimated Monthly Installment (https://en.wikipedia.org/wiki/Equated_monthly_installment)
* EMI = [P x R x (1+R)^N]/[(1+R)^N-1]
* @param principal The starting amount that is owed on the loan.
* @param loanDuration The length of the loan.
* @param cycleDuration The length of the loan's payment cycle.
* @param apr The annual percentage rate of the loan.
*/
function pmt(
uint256 principal,
uint32 loanDuration,
uint32 cycleDuration,
uint16 apr,
uint256 daysInYear
) internal pure returns (uint256) {
require(
loanDuration >= cycleDuration,
"PMT: cycle duration < loan duration"
);
if (apr == 0)
return
Math.mulDiv(
principal,
cycleDuration,
loanDuration,
Math.Rounding.Up
);
// Number of payment cycles for the duration of the loan
uint256 n = Math.ceilDiv(loanDuration, cycleDuration);
uint256 one = WadRayMath.wad();
uint256 r = WadRayMath.pctToWad(apr).wadMul(cycleDuration).wadDiv(
daysInYear
);
uint256 exp = (one + r).wadPow(n);
uint256 numerator = principal.wadMul(r).wadMul(exp);
uint256 denominator = exp - one;
return numerator.wadDiv(denominator);
}
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.5.0;
/// @title Callback for IUniswapV3PoolActions#swap
/// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
interface IUniswapV3SwapCallback {
/// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
/// @dev In the implementation you must pay the pool tokens owed for the swap.
/// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
/// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
/// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
/// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
/// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
/// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
/// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;
/// @notice Supports quoting the calculated amounts from exact input or exact output swaps.
/// @notice For each pool also tells you the number of initialized ticks crossed and the sqrt price of the pool after the swap.
/// @dev These functions are not marked view because they rely on calling non-view functions and reverting
/// to compute the result. They are also not gas efficient and should not be called on-chain.
interface IQuoter {
/// @notice Returns the amount out received for a given exact input swap without executing the swap
/// @param path The path of the swap, i.e. each token pair and the pool fee
/// @param amountIn The amount of the first token to swap
/// @return amountOut The amount of the last token that would be received
/// @return sqrtPriceX96AfterList List of the sqrt price after the swap for each pool in the path
/// @return initializedTicksCrossedList List of number of initialized ticks loaded
function quoteExactInput(bytes memory path, uint256 amountIn)
external
view
returns (
uint256 amountOut,
uint160[] memory sqrtPriceX96AfterList,
uint32[] memory initializedTicksCrossedList,
uint256 gasEstimate
);
struct QuoteExactInputSingleWithPoolParams {
address tokenIn;
address tokenOut;
uint256 amountIn;
address pool;
uint24 fee;
uint160 sqrtPriceLimitX96;
}
/// @notice Returns the amount out received for a given exact input but for a swap of a single pool
/// @param params The params for the quote, encoded as `quoteExactInputSingleWithPool`
/// tokenIn The token being swapped in
/// amountIn The desired input amount
/// tokenOut The token being swapped out
/// fee The fee of the pool to consider for the pair
/// pool The address of the pool to consider for the pair
/// sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
/// @return amountOut The amount of `tokenOut` that would be received
/// @return sqrtPriceX96After The sqrt price of the pool after the swap
/// @return initializedTicksCrossed The number of initialized ticks loaded
function quoteExactInputSingleWithPool(QuoteExactInputSingleWithPoolParams memory params)
external
view
returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
struct QuoteExactInputSingleParams {
address tokenIn;
address tokenOut;
uint256 amountIn;
uint24 fee;
uint160 sqrtPriceLimitX96;
}
/// @notice Returns the amount out received for a given exact input but for a swap of a single pool
/// @param params The params for the quote, encoded as `QuoteExactInputSingleParams`
/// tokenIn The token being swapped in
/// amountIn The desired input amount
/// tokenOut The token being swapped out
/// fee The fee of the token pool to consider for the pair
/// sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
/// @return amountOut The amount of `tokenOut` that would be received
/// @return sqrtPriceX96After The sqrt price of the pool after the swap
/// @return initializedTicksCrossed The number of initialized ticks loaded
function quoteExactInputSingle(QuoteExactInputSingleParams memory params)
external
view
returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
struct QuoteExactOutputSingleWithPoolParams {
address tokenIn;
address tokenOut;
uint256 amount;
uint24 fee;
address pool;
uint160 sqrtPriceLimitX96;
}
/// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
/// @param params The params for the quote, encoded as `QuoteExactOutputSingleWithPoolParams`
/// tokenIn The token being swapped in
/// tokenOut The token being swapped out
/// amount The desired output amount
/// fee The fee of the token pool to consider for the pair
/// pool The address of the pool to consider for the pair
/// sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
/// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
/// @return sqrtPriceX96After The sqrt price of the pool after the swap
/// @return initializedTicksCrossed The number of initialized ticks loaded
function quoteExactOutputSingleWithPool(QuoteExactOutputSingleWithPoolParams memory params)
external
view
returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
struct QuoteExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint256 amount;
uint24 fee;
uint160 sqrtPriceLimitX96;
}
/// @notice Returns the amount in required to receive the given exact output amount but for a swap of a single pool
/// @param params The params for the quote, encoded as `QuoteExactOutputSingleParams`
/// tokenIn The token being swapped in
/// tokenOut The token being swapped out
/// amountOut The desired output amount
/// fee The fee of the token pool to consider for the pair
/// sqrtPriceLimitX96 The price limit of the pool that cannot be exceeded by the swap
/// @return amountIn The amount required as the input for the swap in order to receive `amountOut`
/// @return sqrtPriceX96After The sqrt price of the pool after the swap
/// @return initializedTicksCrossed The number of initialized ticks loaded
function quoteExactOutputSingle(QuoteExactOutputSingleParams memory params)
external
view
returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);
/// @notice Returns the amount in required for a given exact output swap without executing the swap
/// @param path The path of the swap, i.e. each token pair and the pool fee. Path must be provided in reverse order
/// @param amountOut The amount of the last token to receive
/// @return amountIn The amount of first token required to be paid
/// @return sqrtPriceX96AfterList List of the sqrt price after the swap for each pool in the path
/// @return initializedTicksCrossedList List of the initialized ticks that the swap crossed for each pool in the path
function quoteExactOutput(bytes memory path, uint256 amountOut)
external
view
returns (
uint256 amountIn,
uint160[] memory sqrtPriceX96AfterList,
uint32[] memory initializedTicksCrossedList,
uint256 gasEstimate
);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.7.5;
pragma abicoder v2;
import '../../core/interfaces/callback/IUniswapV3SwapCallback.sol';
/// @title Router token swapping functionality
/// @notice Functions for swapping tokens via Uniswap V3
interface ISwapRouter02 is IUniswapV3SwapCallback {
struct ExactInputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
uint160 sqrtPriceLimitX96;
}
/// @notice Swaps `amountIn` of one token for as much as possible of another token
/// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
/// @return amountOut The amount of the received token
function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
struct ExactInputParams {
bytes path;
address recipient;
uint256 amountIn;
uint256 amountOutMinimum;
}
/// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
/// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
/// @return amountOut The amount of the received token
function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
struct ExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 amountOut;
uint256 amountInMaximum;
uint160 sqrtPriceLimitX96;
}
/// @notice Swaps as little as possible of one token for `amountOut` of another token
/// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
/// @return amountIn The amount of the input token
function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
struct ExactOutputParams {
bytes path;
address recipient;
uint256 amountOut;
uint256 amountInMaximum;
}
/// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
/// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
/// @return amountIn The amount of the input token
function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.6.0;
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
library TransferHelper {
/// @notice Transfers tokens from the targeted address to the given destination
/// @notice Errors with 'STF' if transfer fails
/// @param token The contract address of the token to be transferred
/// @param from The originating address from which the tokens will be transferred
/// @param to The destination address of the transfer
/// @param value The amount to be transferred
function safeTransferFrom(
address token,
address from,
address to,
uint256 value
) internal {
(bool success, bytes memory data) =
token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
}
/// @notice Transfers tokens from msg.sender to a recipient
/// @dev Errors with ST if transfer fails
/// @param token The contract address of the token which will be transferred
/// @param to The recipient of the transfer
/// @param value The value of the transfer
function safeTransfer(
address token,
address to,
uint256 value
) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
}
/// @notice Approves the stipulated contract to spend the given allowance in the given token
/// @dev Errors with 'SA' if transfer fails
/// @param token The contract address of the token to be approved
/// @param to The target of the approval
/// @param value The amount of the given token the target will be allowed to spend
function safeApprove(
address token,
address to,
uint256 value
) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
}
/// @notice Transfers ETH to the recipient address
/// @dev Fails with `STE`
/// @param to The destination of the transfer
/// @param value The value to be transferred
function safeTransferETH(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}(new bytes(0));
require(success, 'STE');
}
}pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: MIT
// Libraries
import "./NumbersLib.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import { Bid } from "../TellerV2Storage.sol";
import { BokkyPooBahsDateTimeLibrary as BPBDTL } from "./DateTimeLib.sol";
enum PaymentType {
EMI,
Bullet
}
enum PaymentCycleType {
Seconds,
Monthly
}
library V2Calculations {
using NumbersLib for uint256;
/**
* @notice Returns the timestamp of the last payment made for a loan.
* @param _bid The loan bid struct to get the timestamp for.
*/
function lastRepaidTimestamp(Bid storage _bid)
internal
view
returns (uint32)
{
return
_bid.loanDetails.lastRepaidTimestamp == 0
? _bid.loanDetails.acceptedTimestamp
: _bid.loanDetails.lastRepaidTimestamp;
}
/**
* @notice Calculates the amount owed for a loan.
* @param _bid The loan bid struct to get the owed amount for.
* @param _timestamp The timestamp at which to get the owed amount at.
* @param _paymentCycleType The payment cycle type of the loan (Seconds or Monthly).
*/
function calculateAmountOwed(
Bid storage _bid,
uint256 _timestamp,
PaymentCycleType _paymentCycleType,
uint32 _paymentCycleDuration
)
public
view
returns (
uint256 owedPrincipal_,
uint256 duePrincipal_,
uint256 interest_
)
{
// Total principal left to pay
return
calculateAmountOwed(
_bid,
lastRepaidTimestamp(_bid),
_timestamp,
_paymentCycleType,
_paymentCycleDuration
);
}
function calculateAmountOwed(
Bid storage _bid,
uint256 _lastRepaidTimestamp,
uint256 _timestamp,
PaymentCycleType _paymentCycleType,
uint32 _paymentCycleDuration
)
public
view
returns (
uint256 owedPrincipal_,
uint256 duePrincipal_,
uint256 interest_
)
{
owedPrincipal_ =
_bid.loanDetails.principal -
_bid.loanDetails.totalRepaid.principal;
uint256 owedTime = _timestamp - uint256(_lastRepaidTimestamp);
{
uint256 daysInYear = _paymentCycleType == PaymentCycleType.Monthly
? 360 days
: 365 days;
uint256 interestOwedInAYear = owedPrincipal_.percent(_bid.terms.APR, 2);
interest_ = (interestOwedInAYear * owedTime) / daysInYear;
}
bool isLastPaymentCycle;
{
uint256 lastPaymentCycleDuration = _bid.loanDetails.loanDuration %
_paymentCycleDuration;
if (lastPaymentCycleDuration == 0) {
lastPaymentCycleDuration = _paymentCycleDuration;
}
uint256 endDate = uint256(_bid.loanDetails.acceptedTimestamp) +
uint256(_bid.loanDetails.loanDuration);
uint256 lastPaymentCycleStart = endDate -
uint256(lastPaymentCycleDuration);
isLastPaymentCycle =
uint256(_timestamp) > lastPaymentCycleStart ||
owedPrincipal_ + interest_ <= _bid.terms.paymentCycleAmount;
}
if (_bid.paymentType == PaymentType.Bullet) {
if (isLastPaymentCycle) {
duePrincipal_ = owedPrincipal_;
}
} else {
// Default to PaymentType.EMI
// Max payable amount in a cycle
// NOTE: the last cycle could have less than the calculated payment amount
//the amount owed for the cycle should never exceed the current payment cycle amount so we use min here
uint256 owedAmountForCycle = Math.min( ((_bid.terms.paymentCycleAmount * owedTime) ) /
_paymentCycleDuration , _bid.terms.paymentCycleAmount+interest_ ) ;
uint256 owedAmount = isLastPaymentCycle
? owedPrincipal_ + interest_
: owedAmountForCycle ;
duePrincipal_ = Math.min(owedAmount - interest_, owedPrincipal_);
}
}
/**
* @notice Calculates the amount owed for a loan for the next payment cycle.
* @param _type The payment type of the loan.
* @param _cycleType The cycle type set for the loan. (Seconds or Monthly)
* @param _principal The starting amount that is owed on the loan.
* @param _duration The length of the loan.
* @param _paymentCycle The length of the loan's payment cycle.
* @param _apr The annual percentage rate of the loan.
*/
function calculatePaymentCycleAmount(
PaymentType _type,
PaymentCycleType _cycleType,
uint256 _principal,
uint32 _duration,
uint32 _paymentCycle,
uint16 _apr
) public view returns (uint256) {
uint256 daysInYear = _cycleType == PaymentCycleType.Monthly
? 360 days
: 365 days;
if (_type == PaymentType.Bullet) {
return
_principal.percent(_apr).percent(
uint256(_paymentCycle).ratioOf(daysInYear, 10),
10
);
}
// Default to PaymentType.EMI
return
NumbersLib.pmt(
_principal,
_duration,
_paymentCycle,
_apr,
daysInYear
);
}
function calculateNextDueDate(
uint32 _acceptedTimestamp,
uint32 _paymentCycle,
uint32 _loanDuration,
uint32 _lastRepaidTimestamp,
PaymentCycleType _bidPaymentCycleType
) public view returns (uint32 dueDate_) {
// Calculate due date if payment cycle is set to monthly
if (_bidPaymentCycleType == PaymentCycleType.Monthly) {
// Calculate the cycle number the last repayment was made
uint256 lastPaymentCycle = BPBDTL.diffMonths(
_acceptedTimestamp,
_lastRepaidTimestamp
);
if (
BPBDTL.getDay(_lastRepaidTimestamp) >
BPBDTL.getDay(_acceptedTimestamp)
) {
lastPaymentCycle += 2;
} else {
lastPaymentCycle += 1;
}
dueDate_ = uint32(
BPBDTL.addMonths(_acceptedTimestamp, lastPaymentCycle)
);
} else if (_bidPaymentCycleType == PaymentCycleType.Seconds) {
// Start with the original due date being 1 payment cycle since bid was accepted
dueDate_ = _acceptedTimestamp + _paymentCycle;
// Calculate the cycle number the last repayment was made
uint32 delta = _lastRepaidTimestamp - _acceptedTimestamp;
if (delta > 0) {
uint32 repaymentCycle = uint32(
Math.ceilDiv(delta, _paymentCycle)
);
dueDate_ += (repaymentCycle * _paymentCycle);
}
}
uint32 endOfLoan = _acceptedTimestamp + _loanDuration;
//if we are in the last payment cycle, the next due date is the end of loan duration
if (dueDate_ > endOfLoan) {
dueDate_ = endOfLoan;
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeCast.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
/**
* @title WadRayMath library
* @author Multiplier Finance
* @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)
*/
library WadRayMath {
using SafeMath for uint256;
uint256 internal constant WAD = 1e18;
uint256 internal constant halfWAD = WAD / 2;
uint256 internal constant RAY = 1e27;
uint256 internal constant halfRAY = RAY / 2;
uint256 internal constant WAD_RAY_RATIO = 1e9;
uint256 internal constant PCT_WAD_RATIO = 1e14;
uint256 internal constant PCT_RAY_RATIO = 1e23;
function ray() internal pure returns (uint256) {
return RAY;
}
function wad() internal pure returns (uint256) {
return WAD;
}
function halfRay() internal pure returns (uint256) {
return halfRAY;
}
function halfWad() internal pure returns (uint256) {
return halfWAD;
}
function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {
return halfWAD.add(a.mul(b)).div(WAD);
}
function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 halfB = b / 2;
return halfB.add(a.mul(WAD)).div(b);
}
function rayMul(uint256 a, uint256 b) internal pure returns (uint256) {
return halfRAY.add(a.mul(b)).div(RAY);
}
function rayDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 halfB = b / 2;
return halfB.add(a.mul(RAY)).div(b);
}
function rayToWad(uint256 a) internal pure returns (uint256) {
uint256 halfRatio = WAD_RAY_RATIO / 2;
return halfRatio.add(a).div(WAD_RAY_RATIO);
}
function rayToPct(uint256 a) internal pure returns (uint16) {
uint256 halfRatio = PCT_RAY_RATIO / 2;
uint256 val = halfRatio.add(a).div(PCT_RAY_RATIO);
return SafeCast.toUint16(val);
}
function wadToPct(uint256 a) internal pure returns (uint16) {
uint256 halfRatio = PCT_WAD_RATIO / 2;
uint256 val = halfRatio.add(a).div(PCT_WAD_RATIO);
return SafeCast.toUint16(val);
}
function wadToRay(uint256 a) internal pure returns (uint256) {
return a.mul(WAD_RAY_RATIO);
}
function pctToRay(uint16 a) internal pure returns (uint256) {
return uint256(a).mul(RAY).div(1e4);
}
function pctToWad(uint16 a) internal pure returns (uint256) {
return uint256(a).mul(WAD).div(1e4);
}
/**
* @dev calculates base^duration. The code uses the ModExp precompile
* @return z base^duration, in ray
*/
function rayPow(uint256 x, uint256 n) internal pure returns (uint256) {
return _pow(x, n, RAY, rayMul);
}
function wadPow(uint256 x, uint256 n) internal pure returns (uint256) {
return _pow(x, n, WAD, wadMul);
}
function _pow(
uint256 x,
uint256 n,
uint256 p,
function(uint256, uint256) internal pure returns (uint256) mul
) internal pure returns (uint256 z) {
z = n % 2 != 0 ? x : p;
for (n /= 2; n != 0; n /= 2) {
x = mul(x, x);
if (n % 2 != 0) {
z = mul(z, x);
}
}
}
}pragma solidity >=0.8.0 <0.9.0;
// SPDX-License-Identifier: MIT
import { IMarketRegistry } from "./interfaces/IMarketRegistry.sol";
import "./interfaces/IEscrowVault.sol";
import "./interfaces/IReputationManager.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./interfaces/ICollateralManager.sol";
import { PaymentType, PaymentCycleType } from "./libraries/V2Calculations.sol";
import "./interfaces/ILenderManager.sol";
enum BidState {
NONEXISTENT,
PENDING,
CANCELLED,
ACCEPTED,
PAID,
LIQUIDATED,
CLOSED
}
/**
* @notice Represents a total amount for a payment.
* @param principal Amount that counts towards the principal.
* @param interest Amount that counts toward interest.
*/
struct Payment {
uint256 principal;
uint256 interest;
}
/**
* @notice Details about a loan request.
* @param borrower Account address who is requesting a loan.
* @param receiver Account address who will receive the loan amount.
* @param lender Account address who accepted and funded the loan request.
* @param marketplaceId ID of the marketplace the bid was submitted to.
* @param metadataURI ID of off chain metadata to find additional information of the loan request.
* @param loanDetails Struct of the specific loan details.
* @param terms Struct of the loan request terms.
* @param state Represents the current state of the loan.
*/
struct Bid {
address borrower;
address receiver;
address lender; // if this is the LenderManager address, we use that .owner() as source of truth
uint256 marketplaceId;
bytes32 _metadataURI; // DEPRECATED
LoanDetails loanDetails;
Terms terms;
BidState state;
PaymentType paymentType;
}
/**
* @notice Details about the loan.
* @param lendingToken The token address for the loan.
* @param principal The amount of tokens initially lent out.
* @param totalRepaid Payment struct that represents the total principal and interest amount repaid.
* @param timestamp Timestamp, in seconds, of when the bid was submitted by the borrower.
* @param acceptedTimestamp Timestamp, in seconds, of when the bid was accepted by the lender.
* @param lastRepaidTimestamp Timestamp, in seconds, of when the last payment was made
* @param loanDuration The duration of the loan.
*/
struct LoanDetails {
IERC20 lendingToken;
uint256 principal;
Payment totalRepaid;
uint32 timestamp;
uint32 acceptedTimestamp;
uint32 lastRepaidTimestamp;
uint32 loanDuration;
}
/**
* @notice Information on the terms of a loan request
* @param paymentCycleAmount Value of tokens expected to be repaid every payment cycle.
* @param paymentCycle Duration, in seconds, of how often a payment must be made.
* @param APR Annual percentage rating to be applied on repayments. (10000 == 100%)
*/
struct Terms {
uint256 paymentCycleAmount;
uint32 paymentCycle;
uint16 APR;
}
abstract contract TellerV2Storage_G0 {
/** Storage Variables */
// Current number of bids.
uint256 public bidId;
// Mapping of bidId to bid information.
mapping(uint256 => Bid) public bids;
// Mapping of borrowers to borrower requests.
mapping(address => uint256[]) public borrowerBids;
// Mapping of volume filled by lenders.
mapping(address => uint256) public __lenderVolumeFilled; // DEPRECIATED
// Volume filled by all lenders.
uint256 public __totalVolumeFilled; // DEPRECIATED
// List of allowed lending tokens
EnumerableSet.AddressSet internal __lendingTokensSet; // DEPRECATED
IMarketRegistry public marketRegistry;
IReputationManager public reputationManager;
// Mapping of borrowers to borrower requests.
mapping(address => EnumerableSet.UintSet) internal _borrowerBidsActive;
mapping(uint256 => uint32) public bidDefaultDuration;
mapping(uint256 => uint32) public bidExpirationTime;
// Mapping of volume filled by lenders.
// Asset address => Lender address => Volume amount
mapping(address => mapping(address => uint256)) public lenderVolumeFilled;
// Volume filled by all lenders.
// Asset address => Volume amount
mapping(address => uint256) public totalVolumeFilled;
uint256 public version;
// Mapping of metadataURIs by bidIds.
// Bid Id => metadataURI string
mapping(uint256 => string) public uris;
}
abstract contract TellerV2Storage_G1 is TellerV2Storage_G0 {
// market ID => trusted forwarder
mapping(uint256 => address) internal _trustedMarketForwarders;
// trusted forwarder => set of pre-approved senders
mapping(address => EnumerableSet.AddressSet)
internal _approvedForwarderSenders;
}
abstract contract TellerV2Storage_G2 is TellerV2Storage_G1 {
address public lenderCommitmentForwarder;
}
abstract contract TellerV2Storage_G3 is TellerV2Storage_G2 {
ICollateralManager public collateralManager;
}
abstract contract TellerV2Storage_G4 is TellerV2Storage_G3 {
// Address of the lender manager contract
ILenderManager public lenderManager;
// BidId to payment cycle type (custom or monthly)
mapping(uint256 => PaymentCycleType) public bidPaymentCycleType;
}
abstract contract TellerV2Storage_G5 is TellerV2Storage_G4 {
// Address of the lender manager contract
IEscrowVault public escrowVault;
}
abstract contract TellerV2Storage_G6 is TellerV2Storage_G5 {
mapping(uint256 => address) public repaymentListenerForBid;
}
abstract contract TellerV2Storage_G7 is TellerV2Storage_G6 {
mapping(address => bool) private __pauserRoleBearer;
bool private __liquidationsPaused;
}
abstract contract TellerV2Storage_G8 is TellerV2Storage_G7 {
address protocolFeeRecipient;
}
abstract contract TellerV2Storage is TellerV2Storage_G8 {}pragma solidity >=0.8.0 <0.9.0; // SPDX-License-Identifier: MIT // A representation of an empty/uninitialized UUID. bytes32 constant EMPTY_UUID = 0;
{
"optimizer": {
"enabled": true,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"metadata": {
"useLiteralContent": true
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"address","name":"_tellerV2","type":"address"},{"internalType":"address","name":"_swapRouter","type":"address"},{"internalType":"address","name":"_quoter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"loanId","type":"uint256"},{"indexed":false,"internalType":"address","name":"token0","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"BorrowSwapComplete","type":"event"},{"inputs":[],"name":"TELLER_V2","outputs":[{"internalType":"contract ITellerV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNISWAP_QUOTER","outputs":[{"internalType":"contract IQuoter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNISWAP_SWAP_ROUTER","outputs":[{"internalType":"contract ISwapRouter02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_lenderCommitmentForwarder","type":"address"},{"internalType":"address","name":"_principalToken","type":"address"},{"internalType":"uint256","name":"_additionalInputAmount","type":"uint256"},{"components":[{"components":[{"internalType":"uint24","name":"poolFee","type":"uint24"},{"internalType":"address","name":"tokenOut","type":"address"}],"internalType":"struct BorrowSwap_G3.TokenSwapPath[]","name":"swapPaths","type":"tuple[]"},{"internalType":"uint160","name":"amountOutMinimum","type":"uint160"}],"internalType":"struct BorrowSwap_G3.SwapArgs","name":"_swapArgs","type":"tuple"},{"components":[{"internalType":"uint256","name":"commitmentId","type":"uint256"},{"internalType":"address","name":"smartCommitmentAddress","type":"address"},{"internalType":"uint256","name":"principalAmount","type":"uint256"},{"internalType":"uint256","name":"collateralAmount","type":"uint256"},{"internalType":"uint256","name":"collateralTokenId","type":"uint256"},{"internalType":"address","name":"collateralTokenAddress","type":"address"},{"internalType":"uint16","name":"interestRate","type":"uint16"},{"internalType":"uint32","name":"loanDuration","type":"uint32"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"internalType":"struct BorrowSwap_G3.AcceptCommitmentArgs","name":"_acceptCommitmentArgs","type":"tuple"}],"name":"borrowSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"inputToken","type":"address"},{"components":[{"internalType":"uint24","name":"poolFee","type":"uint24"},{"internalType":"address","name":"tokenOut","type":"address"}],"internalType":"struct BorrowSwap_G3.TokenSwapPath[]","name":"swapPaths","type":"tuple[]"}],"name":"generateSwapPath","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_marketId","type":"uint256"}],"name":"getMarketFeePct","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_lenderCommitmentForwarder","type":"address"},{"internalType":"uint256","name":"_commitmentId","type":"uint256"}],"name":"getMarketIdForCommitment","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"inputToken","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"components":[{"internalType":"uint24","name":"poolFee","type":"uint24"},{"internalType":"address","name":"tokenOut","type":"address"}],"internalType":"struct BorrowSwap_G3.TokenSwapPath[]","name":"swapPaths","type":"tuple[]"}],"name":"quoteExactInput","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000f7b14778035feaf44540a0bc1d4ed859bcb282290000000000000000000000004e1d81a3e627b9294532e990109e4c21d217376c00000000000000000000000092dea23ed1c683940ff1a2f8fe23fe98c5d3041c
-----Decoded View---------------
Arg [0] : _tellerV2 (address): 0xf7B14778035fEAF44540A0bC1D4ED859bCB28229
Arg [1] : _swapRouter (address): 0x4e1d81A3E627b9294532e990109e4c21d217376C
Arg [2] : _quoter (address): 0x92dea23ED1C683940fF1a2f8fE23FE98C5d3041c
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000f7b14778035feaf44540a0bc1d4ed859bcb28229
Arg [1] : 0000000000000000000000004e1d81a3e627b9294532e990109e4c21d217376c
Arg [2] : 00000000000000000000000092dea23ed1c683940ff1a2f8fe23fe98c5d3041c
Loading...
Loading
Loading...
Loading
0xb7fAe1B38ac960706B5a636756bF7450F7a44339
Loading...
Loading
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.