Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
0x60808060 | 19738042 | 174 days ago | IN | 0 ETH | 0.00929751 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
DepositLogic
Compiler Version
v0.8.20+commit.a1b79de6
Optimization Enabled:
Yes with 800 runs
Other Settings:
shanghai EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "./Pool.sol"; import "./Tick.sol"; import "./LiquidityLogic.sol"; import "./interfaces/IPool.sol"; /** * @title Deposit Logic * @author MetaStreet Labs */ library DepositLogic { using LiquidityLogic for LiquidityLogic.Liquidity; /** * @dev Helper function to handle deposit accounting * @param self Pool storage * @param tick Tick * @param amount Amount * @param minShares Minimum shares * @return Deposit shares */ function _deposit( Pool.PoolStorage storage self, uint128 tick, uint128 amount, uint128 minShares ) external returns (uint128) { /* Validate tick */ Tick.validate(tick, 0, 0, self.durations.length - 1, 0, self.rates.length - 1); /* Deposit into liquidity node */ uint128 shares = self.liquidity.deposit(tick, amount); /* Validate shares received is sufficient */ if (shares == 0 || shares < minShares) revert IPool.InsufficientShares(); /* Add to deposit */ self.deposits[msg.sender][tick].shares += shares; return shares; } /** * @dev Helper function to handle redeem accounting * @param self Pool storage * @param tick Tick * @param shares Shares * @return redemptionId Redemption ID */ function _redeem(Pool.PoolStorage storage self, uint128 tick, uint128 shares) external returns (uint128) { /* Look up deposit */ Pool.Deposit storage dep = self.deposits[msg.sender][tick]; /* Assign redemption ID */ uint128 redemptionId = dep.redemptionId++; /* Look up redemption */ Pool.Redemption storage redemption = dep.redemptions[redemptionId]; /* Validate shares */ if (shares == 0 || shares > dep.shares) revert IPool.InsufficientShares(); /* Redeem shares in tick with liquidity manager */ (uint128 index, uint128 target) = self.liquidity.redeem(tick, shares); /* Update deposit state */ redemption.pending = shares; redemption.index = index; redemption.target = target; /* Decrement deposit shares */ dep.shares -= shares; return redemptionId; } /** * @dev Helper function to handle withdraw accounting * @param self Pool storage * @param tick Tick * @param redemptionId Redemption ID * @return Withdrawn shares and withdrawn amount */ function _withdraw( Pool.PoolStorage storage self, uint128 tick, uint128 redemptionId ) external returns (uint128, uint128) { /* Look up redemption */ Pool.Redemption storage redemption = self.deposits[msg.sender][tick].redemptions[redemptionId]; /* If no redemption is pending */ if (redemption.pending == 0) revert IPool.InvalidRedemptionStatus(); /* Look up redemption available */ (uint128 shares, uint128 amount, uint128 processedIndices, uint128 processedShares) = self .liquidity .redemptionAvailable(tick, redemption.pending, redemption.index, redemption.target); /* If the entire redemption is ready */ if (shares == redemption.pending) { delete self.deposits[msg.sender][tick].redemptions[redemptionId]; } else { redemption.pending -= shares; redemption.index += processedIndices; redemption.target = (processedShares < redemption.target) ? redemption.target - processedShares : 0; } return (shares, amount); } /** * @dev Helper function to handle transfer accounting * @param self Pool storage * @param from From * @param to To * @param tick Tick * @param shares Shares */ function _transfer(Pool.PoolStorage storage self, address from, address to, uint128 tick, uint128 shares) external { if (self.deposits[from][tick].shares < shares) revert IPool.InsufficientShares(); self.deposits[from][tick].shares -= shares; self.deposits[to][tick].shares += shares; } /** * Helper function to look up redemption available * @param self Pool storage * @param account Account * @param tick Tick * @param redemptionId Redemption ID * @return shares Amount of deposit shares available for redemption * @return amount Amount of currency tokens available for withdrawal * @return sharesAhead Amount of pending shares ahead in queue */ function _redemptionAvailable( Pool.PoolStorage storage self, address account, uint128 tick, uint128 redemptionId ) external view returns (uint256 shares, uint256 amount, uint256 sharesAhead) { /* Look up redemption */ Pool.Redemption storage redemption = self.deposits[account][tick].redemptions[redemptionId]; /* If no redemption is pending */ if (redemption.pending == 0) return (0, 0, 0); uint128 processedShares; (shares, amount, , processedShares) = self.liquidity.redemptionAvailable( tick, redemption.pending, redemption.index, redemption.target ); /* Compute pending shares ahead in queue */ sharesAhead = redemption.target > processedShares ? redemption.target - processedShares : 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; import "../utils/Context.sol"; import "../utils/Strings.sol"; import "../utils/introspection/ERC165.sol"; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ```solidity * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ```solidity * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules} * to enforce additional security measures for this role. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(account), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol) pragma solidity ^0.8.0; /** * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified * proxy whose upgrades are fully controlled by the current implementation. */ interface IERC1822Proxiable { /** * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation * address. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. */ function proxiableUUID() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol) pragma solidity ^0.8.0; /** * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC. * * _Available since v4.8.3._ */ interface IERC1967 { /** * @dev Emitted when the implementation is upgraded. */ event Upgraded(address indexed implementation); /** * @dev Emitted when the admin account has changed. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Emitted when the beacon is changed. */ event BeaconUpgraded(address indexed beacon); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (interfaces/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../token/ERC20/extensions/IERC20Metadata.sol";
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (interfaces/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../token/ERC721/extensions/IERC721Metadata.sol";
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (proxy/beacon/BeaconProxy.sol) pragma solidity ^0.8.0; import "./IBeacon.sol"; import "../Proxy.sol"; import "../ERC1967/ERC1967Upgrade.sol"; /** * @dev This contract implements a proxy that gets the implementation address for each call from an {UpgradeableBeacon}. * * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't * conflict with the storage layout of the implementation behind the proxy. * * _Available since v3.4._ */ contract BeaconProxy is Proxy, ERC1967Upgrade { /** * @dev Initializes the proxy with `beacon`. * * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This * will typically be an encoded function call, and allows initializing the storage of the proxy like a Solidity * constructor. * * Requirements: * * - `beacon` must be a contract with the interface {IBeacon}. */ constructor(address beacon, bytes memory data) payable { _upgradeBeaconToAndCall(beacon, data, false); } /** * @dev Returns the current beacon address. */ function _beacon() internal view virtual returns (address) { return _getBeacon(); } /** * @dev Returns the current implementation address of the associated beacon. */ function _implementation() internal view virtual override returns (address) { return IBeacon(_getBeacon()).implementation(); } /** * @dev Changes the proxy to use a new beacon. Deprecated: see {_upgradeBeaconToAndCall}. * * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. * * Requirements: * * - `beacon` must be a contract. * - The implementation returned by `beacon` must be a contract. */ function _setBeacon(address beacon, bytes memory data) internal virtual { _upgradeBeaconToAndCall(beacon, data, false); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol) pragma solidity ^0.8.0; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeacon { /** * @dev Must return an address that can be used as a delegate call target. * * {BeaconProxy} will check that this address is a contract. */ function implementation() external view returns (address); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (proxy/beacon/UpgradeableBeacon.sol) pragma solidity ^0.8.0; import "./IBeacon.sol"; import "../../access/Ownable.sol"; import "../../utils/Address.sol"; /** * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their * implementation contract, which is where they will delegate all function calls. * * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon. */ contract UpgradeableBeacon is IBeacon, Ownable { address private _implementation; /** * @dev Emitted when the implementation returned by the beacon is changed. */ event Upgraded(address indexed implementation); /** * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the * beacon. */ constructor(address implementation_) { _setImplementation(implementation_); } /** * @dev Returns the current implementation address. */ function implementation() public view virtual override returns (address) { return _implementation; } /** * @dev Upgrades the beacon to a new implementation. * * Emits an {Upgraded} event. * * Requirements: * * - msg.sender must be the owner of the contract. * - `newImplementation` must be a contract. */ function upgradeTo(address newImplementation) public virtual onlyOwner { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Sets the implementation contract address for this beacon * * Requirements: * * - `newImplementation` must be a contract. */ function _setImplementation(address newImplementation) private { require(Address.isContract(newImplementation), "UpgradeableBeacon: implementation is not a contract"); _implementation = newImplementation; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (proxy/Clones.sol) pragma solidity ^0.8.0; /** * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for * deploying minimal proxy contracts, also known as "clones". * * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies * > a minimal bytecode implementation that delegates all calls to a known, fixed address. * * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2` * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the * deterministic method. * * _Available since v3.4._ */ library Clones { /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. * * This function uses the create opcode, which should never revert. */ function clone(address implementation) internal returns (address instance) { /// @solidity memory-safe-assembly assembly { // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes // of the `implementation` address with the bytecode before the address. mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000)) // Packs the remaining 17 bytes of `implementation` with the bytecode after the address. mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3)) instance := create(0, 0x09, 0x37) } require(instance != address(0), "ERC1167: create failed"); } /** * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `implementation` and `salt` multiple time will revert, since * the clones cannot be deployed twice at the same address. */ function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) { /// @solidity memory-safe-assembly assembly { // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes // of the `implementation` address with the bytecode before the address. mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000)) // Packs the remaining 17 bytes of `implementation` with the bytecode after the address. mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3)) instance := create2(0, 0x09, 0x37, salt) } require(instance != address(0), "ERC1167: create2 failed"); } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress( address implementation, bytes32 salt, address deployer ) internal pure returns (address predicted) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) mstore(add(ptr, 0x38), deployer) mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff) mstore(add(ptr, 0x14), implementation) mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73) mstore(add(ptr, 0x58), salt) mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37)) predicted := keccak256(add(ptr, 0x43), 0x55) } } /** * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}. */ function predictDeterministicAddress( address implementation, bytes32 salt ) internal view returns (address predicted) { return predictDeterministicAddress(implementation, salt, address(this)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol) pragma solidity ^0.8.0; import "../Proxy.sol"; import "./ERC1967Upgrade.sol"; /** * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an * implementation address that can be changed. This address is stored in storage in the location specified by * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the * implementation behind the proxy. */ contract ERC1967Proxy is Proxy, ERC1967Upgrade { /** * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`. * * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded * function call, and allows initializing the storage of the proxy like a Solidity constructor. */ constructor(address _logic, bytes memory _data) payable { _upgradeToAndCall(_logic, _data, false); } /** * @dev Returns the current implementation address. */ function _implementation() internal view virtual override returns (address impl) { return ERC1967Upgrade._getImplementation(); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol) pragma solidity ^0.8.2; import "../beacon/IBeacon.sol"; import "../../interfaces/IERC1967.sol"; import "../../interfaces/draft-IERC1822.sol"; import "../../utils/Address.sol"; import "../../utils/StorageSlot.sol"; /** * @dev This abstract contract provides getters and event emitting update functions for * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. * * _Available since v4.1._ */ abstract contract ERC1967Upgrade is IERC1967 { // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; /** * @dev Storage slot with the address of the current implementation. * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /** * @dev Returns the current implementation address. */ function _getImplementation() internal view returns (address) { return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; } /** * @dev Stores a new address in the EIP1967 implementation slot. */ function _setImplementation(address newImplementation) private { require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; } /** * @dev Perform implementation upgrade * * Emits an {Upgraded} event. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Perform implementation upgrade with additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal { _upgradeTo(newImplementation); if (data.length > 0 || forceCall) { Address.functionDelegateCall(newImplementation, data); } } /** * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal { // Upgrades from old implementations will perform a rollback test. This test requires the new // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing // this special case will break upgrade paths from old UUPS implementation to new ones. if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) { _setImplementation(newImplementation); } else { try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) { require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID"); } catch { revert("ERC1967Upgrade: new implementation is not UUPS"); } _upgradeToAndCall(newImplementation, data, forceCall); } } /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Returns the current admin. */ function _getAdmin() internal view returns (address) { return StorageSlot.getAddressSlot(_ADMIN_SLOT).value; } /** * @dev Stores a new address in the EIP1967 admin slot. */ function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } /** * @dev Changes the admin of the proxy. * * Emits an {AdminChanged} event. */ function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. */ bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Returns the current beacon. */ function _getBeacon() internal view returns (address) { return StorageSlot.getAddressSlot(_BEACON_SLOT).value; } /** * @dev Stores a new beacon in the EIP1967 beacon slot. */ function _setBeacon(address newBeacon) private { require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require( Address.isContract(IBeacon(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract" ); StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon; } /** * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that). * * Emits a {BeaconUpgraded} event. */ function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol) pragma solidity ^0.8.0; /** * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to * be specified by overriding the virtual {_implementation} function. * * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a * different contract through the {_delegate} function. * * The success and return data of the delegated call will be returned back to the caller of the proxy. */ abstract contract Proxy { /** * @dev Delegates the current call to `implementation`. * * This function does not return to its internal call site, it will return directly to the external caller. */ function _delegate(address implementation) internal virtual { assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } /** * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function * and {_fallback} should delegate. */ function _implementation() internal view virtual returns (address); /** * @dev Delegates the current call to the address returned by `_implementation()`. * * This function does not return to its internal call site, it will return directly to the external caller. */ function _fallback() internal virtual { _beforeFallback(); _delegate(_implementation()); } /** * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other * function in the contract matches the call data. */ fallback() external payable virtual { _fallback(); } /** * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data * is empty. */ receive() external payable virtual { _fallback(); } /** * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback` * call, or as part of the Solidity `fallback` or `receive` functions. * * If overridden should call `super._beforeFallback()`. */ function _beforeFallback() internal virtual {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (proxy/transparent/TransparentUpgradeableProxy.sol) pragma solidity ^0.8.0; import "../ERC1967/ERC1967Proxy.sol"; /** * @dev Interface for {TransparentUpgradeableProxy}. In order to implement transparency, {TransparentUpgradeableProxy} * does not implement this interface directly, and some of its functions are implemented by an internal dispatch * mechanism. The compiler is unaware that these functions are implemented by {TransparentUpgradeableProxy} and will not * include them in the ABI so this interface must be used to interact with it. */ interface ITransparentUpgradeableProxy is IERC1967 { function admin() external view returns (address); function implementation() external view returns (address); function changeAdmin(address) external; function upgradeTo(address) external; function upgradeToAndCall(address, bytes memory) external payable; } /** * @dev This contract implements a proxy that is upgradeable by an admin. * * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector * clashing], which can potentially be used in an attack, this contract uses the * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two * things that go hand in hand: * * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if * that call matches one of the admin functions exposed by the proxy itself. * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the * implementation. If the admin tries to call a function on the implementation it will fail with an error that says * "admin cannot fallback to proxy target". * * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due * to sudden errors when trying to call a function from the proxy implementation. * * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way, * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy. * * NOTE: The real interface of this proxy is that defined in `ITransparentUpgradeableProxy`. This contract does not * inherit from that interface, and instead the admin functions are implicitly implemented using a custom dispatch * mechanism in `_fallback`. Consequently, the compiler will not produce an ABI for this contract. This is necessary to * fully implement transparency without decoding reverts caused by selector clashes between the proxy and the * implementation. * * WARNING: It is not recommended to extend this contract to add additional external functions. If you do so, the compiler * will not check that there are no selector conflicts, due to the note above. A selector clash between any new function * and the functions declared in {ITransparentUpgradeableProxy} will be resolved in favor of the new one. This could * render the admin operations inaccessible, which could prevent upgradeability. Transparency may also be compromised. */ contract TransparentUpgradeableProxy is ERC1967Proxy { /** * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}. */ constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) { _changeAdmin(admin_); } /** * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin. * * CAUTION: This modifier is deprecated, as it could cause issues if the modified function has arguments, and the * implementation provides a function with the same selector. */ modifier ifAdmin() { if (msg.sender == _getAdmin()) { _; } else { _fallback(); } } /** * @dev If caller is the admin process the call internally, otherwise transparently fallback to the proxy behavior */ function _fallback() internal virtual override { if (msg.sender == _getAdmin()) { bytes memory ret; bytes4 selector = msg.sig; if (selector == ITransparentUpgradeableProxy.upgradeTo.selector) { ret = _dispatchUpgradeTo(); } else if (selector == ITransparentUpgradeableProxy.upgradeToAndCall.selector) { ret = _dispatchUpgradeToAndCall(); } else if (selector == ITransparentUpgradeableProxy.changeAdmin.selector) { ret = _dispatchChangeAdmin(); } else if (selector == ITransparentUpgradeableProxy.admin.selector) { ret = _dispatchAdmin(); } else if (selector == ITransparentUpgradeableProxy.implementation.selector) { ret = _dispatchImplementation(); } else { revert("TransparentUpgradeableProxy: admin cannot fallback to proxy target"); } assembly { return(add(ret, 0x20), mload(ret)) } } else { super._fallback(); } } /** * @dev Returns the current admin. * * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103` */ function _dispatchAdmin() private returns (bytes memory) { _requireZeroValue(); address admin = _getAdmin(); return abi.encode(admin); } /** * @dev Returns the current implementation. * * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc` */ function _dispatchImplementation() private returns (bytes memory) { _requireZeroValue(); address implementation = _implementation(); return abi.encode(implementation); } /** * @dev Changes the admin of the proxy. * * Emits an {AdminChanged} event. */ function _dispatchChangeAdmin() private returns (bytes memory) { _requireZeroValue(); address newAdmin = abi.decode(msg.data[4:], (address)); _changeAdmin(newAdmin); return ""; } /** * @dev Upgrade the implementation of the proxy. */ function _dispatchUpgradeTo() private returns (bytes memory) { _requireZeroValue(); address newImplementation = abi.decode(msg.data[4:], (address)); _upgradeToAndCall(newImplementation, bytes(""), false); return ""; } /** * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the * proxied contract. */ function _dispatchUpgradeToAndCall() private returns (bytes memory) { (address newImplementation, bytes memory data) = abi.decode(msg.data[4:], (address, bytes)); _upgradeToAndCall(newImplementation, data, true); return ""; } /** * @dev Returns the current admin. * * CAUTION: This function is deprecated. Use {ERC1967Upgrade-_getAdmin} instead. */ function _admin() internal view virtual returns (address) { return _getAdmin(); } /** * @dev To keep this contract fully transparent, all `ifAdmin` functions must be payable. This helper is here to * emulate some proxy functions being non-payable while still allowing value to pass through. */ function _requireZeroValue() private { require(msg.value == 0); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { return _status == _ENTERED; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/ERC1155.sol) pragma solidity ^0.8.0; import "./IERC1155.sol"; import "./IERC1155Receiver.sol"; import "./extensions/IERC1155MetadataURI.sol"; import "../../utils/Address.sol"; import "../../utils/Context.sol"; import "../../utils/introspection/ERC165.sol"; /** * @dev Implementation of the basic standard multi-token. * See https://eips.ethereum.org/EIPS/eip-1155 * Originally based on code by Enjin: https://github.com/enjin/erc-1155 * * _Available since v3.1._ */ contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI { using Address for address; // Mapping from token ID to account balances mapping(uint256 => mapping(address => uint256)) private _balances; // Mapping from account to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json string private _uri; /** * @dev See {_setURI}. */ constructor(string memory uri_) { _setURI(uri_); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC1155).interfaceId || interfaceId == type(IERC1155MetadataURI).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC1155MetadataURI-uri}. * * This implementation returns the same URI for *all* token types. It relies * on the token type ID substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. * * Clients calling this function must replace the `\{id\}` substring with the * actual token type ID. */ function uri(uint256) public view virtual override returns (string memory) { return _uri; } /** * @dev See {IERC1155-balanceOf}. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) public view virtual override returns (uint256) { require(account != address(0), "ERC1155: address zero is not a valid owner"); return _balances[id][account]; } /** * @dev See {IERC1155-balanceOfBatch}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] memory accounts, uint256[] memory ids ) public view virtual override returns (uint256[] memory) { require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch"); uint256[] memory batchBalances = new uint256[](accounts.length); for (uint256 i = 0; i < accounts.length; ++i) { batchBalances[i] = balanceOf(accounts[i], ids[i]); } return batchBalances; } /** * @dev See {IERC1155-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC1155-isApprovedForAll}. */ function isApprovedForAll(address account, address operator) public view virtual override returns (bool) { return _operatorApprovals[account][operator]; } /** * @dev See {IERC1155-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes memory data ) public virtual override { require( from == _msgSender() || isApprovedForAll(from, _msgSender()), "ERC1155: caller is not token owner or approved" ); _safeTransferFrom(from, to, id, amount, data); } /** * @dev See {IERC1155-safeBatchTransferFrom}. */ function safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) public virtual override { require( from == _msgSender() || isApprovedForAll(from, _msgSender()), "ERC1155: caller is not token owner or approved" ); _safeBatchTransferFrom(from, to, ids, amounts, data); } /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes memory data ) internal virtual { require(to != address(0), "ERC1155: transfer to the zero address"); address operator = _msgSender(); uint256[] memory ids = _asSingletonArray(id); uint256[] memory amounts = _asSingletonArray(amount); _beforeTokenTransfer(operator, from, to, ids, amounts, data); uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: insufficient balance for transfer"); unchecked { _balances[id][from] = fromBalance - amount; } _balances[id][to] += amount; emit TransferSingle(operator, from, to, id, amount); _afterTokenTransfer(operator, from, to, ids, amounts, data); _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function _safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); require(to != address(0), "ERC1155: transfer to the zero address"); address operator = _msgSender(); _beforeTokenTransfer(operator, from, to, ids, amounts, data); for (uint256 i = 0; i < ids.length; ++i) { uint256 id = ids[i]; uint256 amount = amounts[i]; uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: insufficient balance for transfer"); unchecked { _balances[id][from] = fromBalance - amount; } _balances[id][to] += amount; } emit TransferBatch(operator, from, to, ids, amounts); _afterTokenTransfer(operator, from, to, ids, amounts, data); _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data); } /** * @dev Sets a new URI for all token types, by relying on the token type ID * substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. * * By this mechanism, any occurrence of the `\{id\}` substring in either the * URI or any of the amounts in the JSON file at said URI will be replaced by * clients with the token type ID. * * For example, the `https://token-cdn-domain/\{id\}.json` URI would be * interpreted by clients as * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json` * for token type ID 0x4cce0. * * See {uri}. * * Because these URIs cannot be meaningfully represented by the {URI} event, * this function emits no events. */ function _setURI(string memory newuri) internal virtual { _uri = newuri; } /** * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal virtual { require(to != address(0), "ERC1155: mint to the zero address"); address operator = _msgSender(); uint256[] memory ids = _asSingletonArray(id); uint256[] memory amounts = _asSingletonArray(amount); _beforeTokenTransfer(operator, address(0), to, ids, amounts, data); _balances[id][to] += amount; emit TransferSingle(operator, address(0), to, id, amount); _afterTokenTransfer(operator, address(0), to, ids, amounts, data); _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function _mintBatch( address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { require(to != address(0), "ERC1155: mint to the zero address"); require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); address operator = _msgSender(); _beforeTokenTransfer(operator, address(0), to, ids, amounts, data); for (uint256 i = 0; i < ids.length; i++) { _balances[ids[i]][to] += amounts[i]; } emit TransferBatch(operator, address(0), to, ids, amounts); _afterTokenTransfer(operator, address(0), to, ids, amounts, data); _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data); } /** * @dev Destroys `amount` tokens of token type `id` from `from` * * Emits a {TransferSingle} event. * * Requirements: * * - `from` cannot be the zero address. * - `from` must have at least `amount` tokens of token type `id`. */ function _burn(address from, uint256 id, uint256 amount) internal virtual { require(from != address(0), "ERC1155: burn from the zero address"); address operator = _msgSender(); uint256[] memory ids = _asSingletonArray(id); uint256[] memory amounts = _asSingletonArray(amount); _beforeTokenTransfer(operator, from, address(0), ids, amounts, ""); uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: burn amount exceeds balance"); unchecked { _balances[id][from] = fromBalance - amount; } emit TransferSingle(operator, from, address(0), id, amount); _afterTokenTransfer(operator, from, address(0), ids, amounts, ""); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. */ function _burnBatch(address from, uint256[] memory ids, uint256[] memory amounts) internal virtual { require(from != address(0), "ERC1155: burn from the zero address"); require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); address operator = _msgSender(); _beforeTokenTransfer(operator, from, address(0), ids, amounts, ""); for (uint256 i = 0; i < ids.length; i++) { uint256 id = ids[i]; uint256 amount = amounts[i]; uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: burn amount exceeds balance"); unchecked { _balances[id][from] = fromBalance - amount; } } emit TransferBatch(operator, from, address(0), ids, amounts); _afterTokenTransfer(operator, from, address(0), ids, amounts, ""); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { require(owner != operator, "ERC1155: setting approval status for self"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Hook that is called before any token transfer. This includes minting * and burning, as well as batched variants. * * The same hook is called on both single and batched variants. For single * transfers, the length of the `ids` and `amounts` arrays will be 1. * * Calling conditions (for each `id` and `amount` pair): * * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens * of token type `id` will be transferred to `to`. * - When `from` is zero, `amount` tokens of token type `id` will be minted * for `to`. * - when `to` is zero, `amount` of ``from``'s tokens of token type `id` * will be burned. * - `from` and `to` are never both zero. * - `ids` and `amounts` have the same, non-zero length. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual {} /** * @dev Hook that is called after any token transfer. This includes minting * and burning, as well as batched variants. * * The same hook is called on both single and batched variants. For single * transfers, the length of the `id` and `amount` arrays will be 1. * * Calling conditions (for each `id` and `amount` pair): * * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens * of token type `id` will be transferred to `to`. * - When `from` is zero, `amount` tokens of token type `id` will be minted * for `to`. * - when `to` is zero, `amount` of ``from``'s tokens of token type `id` * will be burned. * - `from` and `to` are never both zero. * - `ids` and `amounts` have the same, non-zero length. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual {} function _doSafeTransferAcceptanceCheck( address operator, address from, address to, uint256 id, uint256 amount, bytes memory data ) private { if (to.isContract()) { try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) { if (response != IERC1155Receiver.onERC1155Received.selector) { revert("ERC1155: ERC1155Receiver rejected tokens"); } } catch Error(string memory reason) { revert(reason); } catch { revert("ERC1155: transfer to non-ERC1155Receiver implementer"); } } } function _doSafeBatchTransferAcceptanceCheck( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) private { if (to.isContract()) { try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns ( bytes4 response ) { if (response != IERC1155Receiver.onERC1155BatchReceived.selector) { revert("ERC1155: ERC1155Receiver rejected tokens"); } } catch Error(string memory reason) { revert(reason); } catch { revert("ERC1155: transfer to non-ERC1155Receiver implementer"); } } } function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) { uint256[] memory array = new uint256[](1); array[0] = element; return array; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol) pragma solidity ^0.8.0; import "../IERC1155.sol"; /** * @dev Interface of the optional ERC1155MetadataExtension interface, as defined * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. * * _Available since v3.1._ */ interface IERC1155MetadataURI is IERC1155 { /** * @dev Returns the URI for token type `id`. * * If the `\{id\}` substring is present in the URI, it must be replaced by * clients with the actual token type ID. */ function uri(uint256 id) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/IERC1155.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] calldata accounts, uint256[] calldata ids ) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev _Available since v3.1._ */ interface IERC1155Receiver is IERC165 { /** * @dev Handles the receipt of a single ERC1155 token type. This function is * called at the end of a `safeTransferFrom` after the balance has been updated. * * NOTE: To accept the transfer, this must return * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` * (i.e. 0xf23a6e61, or its own function selector). * * @param operator The address which initiated the transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param id The ID of the token being transferred * @param value The amount of tokens being transferred * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); /** * @dev Handles the receipt of a multiple ERC1155 token types. This function * is called at the end of a `safeBatchTransferFrom` after the balances have * been updated. * * NOTE: To accept the transfer(s), this must return * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` * (i.e. 0xbc197c81, or its own function selector). * * @param operator The address which initiated the batch transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param ids An array containing ids of each token being transferred (order and length must match values array) * @param values An array containing amounts of each token being transferred (order and length must match ids array) * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol) pragma solidity ^0.8.0; import "./ERC1155Receiver.sol"; /** * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens. * * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be * stuck. * * @dev _Available since v3.1._ */ contract ERC1155Holder is ERC1155Receiver { function onERC1155Received( address, address, uint256, uint256, bytes memory ) public virtual override returns (bytes4) { return this.onERC1155Received.selector; } function onERC1155BatchReceived( address, address, uint256[] memory, uint256[] memory, bytes memory ) public virtual override returns (bytes4) { return this.onERC1155BatchReceived.selector; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol) pragma solidity ^0.8.0; import "../IERC1155Receiver.sol"; import "../../../utils/introspection/ERC165.sol"; /** * @dev _Available since v3.1._ */ abstract contract ERC1155Receiver is ERC165, IERC1155Receiver { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; import "./IERC20.sol"; import "./extensions/IERC20Metadata.sol"; import "../../utils/Context.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * The default value of {decimals} is 18. To change this, you should override * this function so it returns a different value. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the default value returned by this function, unless * it's overridden. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer(address from, address to, uint256 amount) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by // decrementing then incrementing. _balances[to] += amount; } emit Transfer(from, to, amount); _afterTokenTransfer(from, to, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; unchecked { // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above. _balances[account] += amount; } emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; // Overflow not possible: amount <= accountBalance <= totalSupply. _totalSupply -= amount; } emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance(address owner, address spender, uint256 amount) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol) pragma solidity ^0.8.0; import "../ERC20.sol"; import "../../../utils/Context.sol"; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { _spendAllowance(account, _msgSender(), amount); _burn(account, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.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.9.0) (token/ERC20/presets/ERC20PresetFixedSupply.sol) pragma solidity ^0.8.0; import "../extensions/ERC20Burnable.sol"; /** * @dev {ERC20} token, including: * * - Preminted initial supply * - Ability for holders to burn (destroy) their tokens * - No access control mechanism (for minting/pausing) and hence no governance * * This contract uses {ERC20Burnable} to include burn capabilities - head to * its documentation for details. * * _Available since v3.4._ * * _Deprecated in favor of https://wizard.openzeppelin.com/[Contracts Wizard]._ */ contract ERC20PresetFixedSupply is ERC20Burnable { /** * @dev Mints `initialSupply` amount of token and transfers them to `owner`. * * See {ERC20-constructor}. */ constructor(string memory name, string memory symbol, uint256 initialSupply, address owner) ERC20(name, symbol) { _mint(owner, initialSupply); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; import "../extensions/IERC20Permit.sol"; import "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; /** * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } /** * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. */ function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } /** * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 oldAllowance = token.allowance(address(this), spender); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value)); } /** * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. */ function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value)); } } /** * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval * to be set to zero before setting it to a non-zero value, such as USDT. */ function forceApprove(IERC20 token, address spender, uint256 value) internal { bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value); if (!_callOptionalReturnBool(token, approvalCall)) { _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0)); _callOptionalReturn(token, approvalCall); } } /** * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`. * Revert on invalid signature. */ function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). * * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead. */ function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false // and not revert is the subcall reverts. (bool success, bytes memory returndata) = address(token).call(data); return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; import "./IERC721.sol"; import "./IERC721Receiver.sol"; import "./extensions/IERC721Metadata.sol"; import "../../utils/Address.sol"; import "../../utils/Context.sol"; import "../../utils/Strings.sol"; import "../../utils/introspection/ERC165.sol"; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _ownerOf(tokenId); require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner or approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom(address from, address to, uint256 tokenId) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _safeTransfer(from, to, tokenId, data); } /** * @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. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _ownerOf(tokenId) != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId, 1); // Check that tokenId was not minted by `_beforeTokenTransfer` hook require(!_exists(tokenId), "ERC721: token already minted"); unchecked { // Will not overflow unless all 2**256 token ids are minted to the same owner. // Given that tokens are minted one by one, it is impossible in practice that // this ever happens. Might change if we allow batch minting. // The ERC fails to describe this case. _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId, 1); // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook owner = ERC721.ownerOf(tokenId); // Clear approvals delete _tokenApprovals[tokenId]; unchecked { // Cannot overflow, as that would require more tokens to be burned/transferred // out than the owner initially received through minting and transferring in. _balances[owner] -= 1; } delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId, 1); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer(address from, address to, uint256 tokenId) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId, 1); // Check that tokenId was not transferred by `_beforeTokenTransfer` hook require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); // Clear approvals from the previous owner delete _tokenApprovals[tokenId]; unchecked { // `_balances[from]` cannot overflow for the same reason as described in `_burn`: // `from`'s balance is the number of token held, which is at least one before the current // transfer. // `_balances[to]` could overflow in the conditions described in `_mint`. That would require // all 2**256 token ids to be minted, which in practice is impossible. _balances[from] -= 1; _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`. * - When `from` is zero, the tokens will be minted for `to`. * - When `to` is zero, ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {} /** * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`. * - When `from` is zero, the tokens were minted for `to`. * - When `to` is zero, ``from``'s tokens were burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {} /** * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override. * * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such * that `ownerOf(tokenId)` is `a`. */ // solhint-disable-next-line func-name-mixedcase function __unsafe_increaseBalance(address account, uint256 amount) internal { _balances[account] += amount; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @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.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/utils/ERC721Holder.sol) pragma solidity ^0.8.0; import "../IERC721Receiver.sol"; /** * @dev Implementation of the {IERC721Receiver} interface. * * Accepts all token transfers. * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}. */ contract ERC721Holder is IERC721Receiver { /** * @dev See {IERC721Receiver-onERC721Received}. * * Always returns `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) { return this.onERC721Received.selector; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * * Furthermore, `isContract` will also return true if the target contract within * the same transaction is already scheduled for destruction by `SELFDESTRUCT`, * which only has an effect at the end of a transaction. * ==== * * [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://consensys.net/diligence/blog/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.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Create2.sol) pragma solidity ^0.8.0; /** * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer. * `CREATE2` can be used to compute in advance the address where a smart * contract will be deployed, which allows for interesting new mechanisms known * as 'counterfactual interactions'. * * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more * information. */ library Create2 { /** * @dev Deploys a contract using `CREATE2`. The address where the contract * will be deployed can be known in advance via {computeAddress}. * * The bytecode for a contract can be obtained from Solidity with * `type(contractName).creationCode`. * * Requirements: * * - `bytecode` must not be empty. * - `salt` must have not been used for `bytecode` already. * - the factory must have a balance of at least `amount`. * - if `amount` is non-zero, `bytecode` must have a `payable` constructor. */ function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) { require(address(this).balance >= amount, "Create2: insufficient balance"); require(bytecode.length != 0, "Create2: bytecode length is zero"); /// @solidity memory-safe-assembly assembly { addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt) } require(addr != address(0), "Create2: Failed on deploy"); } /** * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the * `bytecodeHash` or `salt` will result in a new destination address. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) { return computeAddress(salt, bytecodeHash, address(this)); } /** * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}. */ function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) { /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) // Get free memory pointer // | | ↓ ptr ... ↓ ptr + 0x0B (start) ... ↓ ptr + 0x20 ... ↓ ptr + 0x40 ... | // |-------------------|---------------------------------------------------------------------------| // | bytecodeHash | CCCCCCCCCCCCC...CC | // | salt | BBBBBBBBBBBBB...BB | // | deployer | 000000...0000AAAAAAAAAAAAAAAAAAA...AA | // | 0xFF | FF | // |-------------------|---------------------------------------------------------------------------| // | memory | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC | // | keccak(start, 85) | ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ | mstore(add(ptr, 0x40), bytecodeHash) mstore(add(ptr, 0x20), salt) mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff mstore8(start, 0xff) addr := keccak256(start, 85) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol) pragma solidity ^0.8.0; /** * @dev These functions deal with verification of Merkle Tree proofs. * * The tree and the proofs can be generated using our * https://github.com/OpenZeppelin/merkle-tree[JavaScript library]. * You will find a quickstart guide in the readme. * * WARNING: You should avoid using leaf values that are 64 bytes long prior to * hashing, or use a hash function other than keccak256 for hashing leaves. * This is because the concatenation of a sorted pair of internal nodes in * the merkle tree could be reinterpreted as a leaf value. * OpenZeppelin's JavaScript library generates merkle trees that are safe * against this attack out of the box. */ library MerkleProof { /** * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree * defined by `root`. For this, a `proof` must be provided, containing * sibling hashes on the branch from the leaf to the root of the tree. Each * pair of leaves and each pair of pre-images are assumed to be sorted. */ function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { return processProof(proof, leaf) == root; } /** * @dev Calldata version of {verify} * * _Available since v4.7._ */ function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { return processProofCalldata(proof, leaf) == root; } /** * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt * hash matches the root of the tree. When processing the proof, the pairs * of leafs & pre-images are assumed to be sorted. * * _Available since v4.4._ */ function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Calldata version of {processProof} * * _Available since v4.7._ */ function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerify( bytes32[] memory proof, bool[] memory proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProof(proof, proofFlags, leaves) == root; } /** * @dev Calldata version of {multiProofVerify} * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerifyCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProofCalldata(proof, proofFlags, leaves) == root; } /** * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false * respectively. * * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer). * * _Available since v4.7._ */ function processMultiProof( bytes32[] memory proof, bool[] memory proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 proofLen = proof.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]) : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { require(proofPos == proofLen, "MerkleProof: invalid multiproof"); unchecked { return hashes[totalHashes - 1]; } } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } /** * @dev Calldata version of {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function processMultiProofCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 proofLen = proof.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]) : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { require(proofPos == proofLen, "MerkleProof: invalid multiproof"); unchecked { return hashes[totalHashes - 1]; } } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) { return a < b ? _efficientHash(a, b) : _efficientHash(b, a); } function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) { /// @solidity memory-safe-assembly assembly { mstore(0x00, a) mstore(0x20, b) value := keccak256(0x00, 0x40) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/introspection/ERC165Checker.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Library used to query support of an interface declared via {IERC165}. * * Note that these functions return the actual result of the query: they do not * `revert` if an interface is not supported. It is up to the caller to decide * what to do in these cases. */ library ERC165Checker { // As per the EIP-165 spec, no interface should ever match 0xffffffff bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff; /** * @dev Returns true if `account` supports the {IERC165} interface. */ function supportsERC165(address account) internal view returns (bool) { // Any contract that implements ERC165 must explicitly indicate support of // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid return supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) && !supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID); } /** * @dev Returns true if `account` supports the interface defined by * `interfaceId`. Support for {IERC165} itself is queried automatically. * * See {IERC165-supportsInterface}. */ function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) { // query support of both ERC165 as per the spec and support of _interfaceId return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId); } /** * @dev Returns a boolean array where each value corresponds to the * interfaces passed in and whether they're supported or not. This allows * you to batch check interfaces for a contract where your expectation * is that some interfaces may not be supported. * * See {IERC165-supportsInterface}. * * _Available since v3.4._ */ function getSupportedInterfaces( address account, bytes4[] memory interfaceIds ) internal view returns (bool[] memory) { // an array of booleans corresponding to interfaceIds and whether they're supported or not bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length); // query support of ERC165 itself if (supportsERC165(account)) { // query support of each interface in interfaceIds for (uint256 i = 0; i < interfaceIds.length; i++) { interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]); } } return interfaceIdsSupported; } /** * @dev Returns true if `account` supports all the interfaces defined in * `interfaceIds`. Support for {IERC165} itself is queried automatically. * * Batch-querying can lead to gas savings by skipping repeated checks for * {IERC165} support. * * See {IERC165-supportsInterface}. */ function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) { // query support of ERC165 itself if (!supportsERC165(account)) { return false; } // query support of each interface in interfaceIds for (uint256 i = 0; i < interfaceIds.length; i++) { if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) { return false; } } // all interfaces supported return true; } /** * @notice Query if a contract implements an interface, does not check ERC165 support * @param account The address of the contract to query for support of an interface * @param interfaceId The interface identifier, as specified in ERC-165 * @return true if the contract at account indicates support of the interface with * identifier interfaceId, false otherwise * @dev Assumes that account contains a contract that supports ERC165, otherwise * the behavior of this method is undefined. This precondition can be checked * with {supportsERC165}. * * Some precompiled contracts will falsely indicate support for a given interface, so caution * should be exercised when using this function. * * Interface identification is specified in ERC-165. */ function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) { // prepare call bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId); // perform static call bool success; uint256 returnSize; uint256 returnValue; assembly { success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20) returnSize := returndatasize() returnValue := mload(0x00) } return success && returnSize >= 0x20 && returnValue > 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.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) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 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 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < 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.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Multicall.sol) pragma solidity ^0.8.0; import "./Address.sol"; /** * @dev Provides a function to batch together multiple calls in a single external call. * * _Available since v4.1._ */ abstract contract Multicall { /** * @dev Receives and executes a batch of function calls on this contract. * @custom:oz-upgrades-unsafe-allow-reachable delegatecall */ function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) { results = new bytes[](data.length); for (uint256 i = 0; i < data.length; i++) { results[i] = Address.functionDelegateCall(address(this), data[i]); } return results; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.0; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ```solidity * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._ * _Available since v4.9 for `string`, `bytes`._ */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } /** * @dev Returns an `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; import "./math/SignedMath.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.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. * * ```solidity * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/utils/math/Math.sol"; import "@openzeppelin/contracts/utils/math/SafeCast.sol"; import "./Pool.sol"; import "./LoanReceipt.sol"; import "./LiquidityLogic.sol"; import "./interfaces/IPool.sol"; import "./integrations/DelegateCash/IDelegateRegistryV1.sol"; import "./integrations/DelegateCash/IDelegateRegistryV2.sol"; /** * @title Borrow Logic * @author MetaStreet Labs */ library BorrowLogic { using SafeCast for uint256; using LiquidityLogic for LiquidityLogic.Liquidity; /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Borrow options tag size in bytes */ uint256 internal constant BORROW_OPTIONS_TAG_SIZE = 2; /** * @notice Borrow options length size in bytes */ uint256 internal constant BORROW_OPTIONS_LENGTH_SIZE = 2; /**************************************************************************/ /* Helpers */ /**************************************************************************/ /** * @notice Helper function to extract specified option tag from options * data * * @dev Options are encoded as: * 2 byte uint16 tag * 2 byte uint16 length * n byte bytes data * The first matching tag is returned. * * @param options Encoded options * @param tag Tag to find * @return Options data */ function _getOptionsData(bytes calldata options, Pool.BorrowOptions tag) internal pure returns (bytes calldata) { /* Scan the options for the tag */ for (uint256 offsetTag; offsetTag < options.length; ) { /* Compute offsets with for tag length and data */ uint256 offsetLength = offsetTag + BORROW_OPTIONS_TAG_SIZE; uint256 offsetData = offsetTag + BORROW_OPTIONS_TAG_SIZE + BORROW_OPTIONS_LENGTH_SIZE; /* The tag is in the first 2 bytes of each options item */ uint256 currentTag = uint16(bytes2(options[offsetTag:offsetLength])); /* The length of the options data is in the second 2 bytes of each options item, after the tag */ uint256 dataLength = uint16(bytes2(options[offsetLength:offsetData])); /* Return the offset and length if the tag is found */ if (currentTag == uint256(tag)) { return options[offsetData:offsetData + dataLength]; } /* Increment to next options item */ offsetTag = offsetData + dataLength; } /* Return empty slice if no tag is found */ return options[0:0]; } /** * @notice Helper function that calls delegate.cash registry to delegate token * * @param delegations Delegate storage * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param delegateRegistryV1 Delegate registry v1 address * @param delegateRegistryV2 Delegate registry v2 address * @param options Options data */ function _optionDelegateCash( Pool.DelegateStorage storage delegations, address collateralToken, uint256 collateralTokenId, address delegateRegistryV1, address delegateRegistryV2, bytes calldata options ) internal { /* Find delegate.cash v2 tagged data in options */ bytes calldata delegateDataV2 = _getOptionsData(options, Pool.BorrowOptions.DelegateCashV2); if (delegateDataV2.length != 0) { if (delegateRegistryV2 == address(0)) revert IPool.InvalidBorrowOptions(); if (delegateDataV2.length != 20) revert IPool.InvalidBorrowOptions(); /* Store delegate in mapping */ delegations.delegates[collateralToken][collateralTokenId] = Pool.Delegate({ version: Pool.DelegateVersion.DelegateCashV2, to: address(uint160(bytes20(delegateDataV2))) }); /* Delegate token */ IDelegateRegistryV2(delegateRegistryV2).delegateERC721( address(uint160(bytes20(delegateDataV2))), collateralToken, collateralTokenId, "", true ); /* Return if found, skip additional search */ return; } /* Find delegate.cash v1 tagged data in options, if v2 data is empty */ bytes calldata delegateDataV1 = _getOptionsData(options, Pool.BorrowOptions.DelegateCashV1); if (delegateDataV1.length != 0) { if (delegateRegistryV1 == address(0)) revert IPool.InvalidBorrowOptions(); if (delegateDataV1.length != 20) revert IPool.InvalidBorrowOptions(); /* Store delegate in mapping */ delegations.delegates[collateralToken][collateralTokenId] = Pool.Delegate({ version: Pool.DelegateVersion.DelegateCashV1, to: address(uint160(bytes20(delegateDataV1))) }); /* Delegate token */ IDelegateRegistryV1(delegateRegistryV1).delegateForToken( address(uint160(bytes20(delegateDataV1))), collateralToken, collateralTokenId, true ); } } /** * @notice Helper function to revoke token delegate * * @param delegations Delegate storage * @param collateralToken Contract address of token that delegation is being removed from * @param collateralTokenId Token id of token that delegation is being removed from * @param delegateRegistryV1 Delegate registry v1 address * @param delegateRegistryV2 Delegate registry v2 address */ function _revokeDelegates( Pool.DelegateStorage storage delegations, address collateralToken, uint256 collateralTokenId, address delegateRegistryV1, address delegateRegistryV2 ) internal { Pool.Delegate memory delegate = delegations.delegates[collateralToken][collateralTokenId]; if (delegate.version == Pool.DelegateVersion.None) { return; } else if (delegate.version == Pool.DelegateVersion.DelegateCashV2) { IDelegateRegistryV2(delegateRegistryV2).delegateERC721( delegate.to, collateralToken, collateralTokenId, "", false ); } else if (delegate.version == Pool.DelegateVersion.DelegateCashV1) { IDelegateRegistryV1(delegateRegistryV1).delegateForToken( delegate.to, collateralToken, collateralTokenId, false ); } /* Remove delegate from mapping */ delete delegations.delegates[collateralToken][collateralTokenId]; } /** * @dev Helper function to calculated prorated repayment * @param loanReceipt Decoded loan receipt * @return repayment amount in currency tokens * @return proration based on elapsed duration */ function _prorateRepayment( LoanReceipt.LoanReceiptV2 memory loanReceipt ) internal view returns (uint256 repayment, uint256 proration) { /* Minimum of proration and 1.0 */ proration = Math.min( ((block.timestamp - (loanReceipt.maturity - loanReceipt.duration)) * LiquidityLogic.FIXED_POINT_SCALE) / loanReceipt.duration, LiquidityLogic.FIXED_POINT_SCALE ); /* Compute repayment using prorated interest */ repayment = loanReceipt.principal + (((loanReceipt.repayment - loanReceipt.principal) * proration) / LiquidityLogic.FIXED_POINT_SCALE); } /** * @dev Helper function to decode a loan receipt * @param loanReceipt Loan receipt * @return Decoded loan receipt */ function _decodeLoanReceipt(bytes calldata loanReceipt) external pure returns (LoanReceipt.LoanReceiptV2 memory) { return LoanReceipt.decode(loanReceipt); } /** * @dev Helper function to handle borrow accounting * @param self Pool storage * @param principal Principal amount in currency tokens * @param duration Duration in seconds * @param collateralToken Collateral token address * @param collateralTokenId Collateral token ID * @param repayment Repayment amount in currency tokens * @param maxRepayment Maximum repayment amount in currency tokens * @param adminFee Admin fee * @param nodes Liquidity nodes * @param count Liquidity nodes count * @param collateralWrapperContext Collateral wrapper context data * @return Encoded loan receipt, loan receipt hash */ function _borrow( Pool.PoolStorage storage self, uint256 principal, uint64 duration, address collateralToken, uint256 collateralTokenId, uint256 repayment, uint256 maxRepayment, uint256 adminFee, LiquidityLogic.NodeSource[] memory nodes, uint16 count, bytes memory collateralWrapperContext ) external returns (bytes memory, bytes32) { /* Validate principal is non-zero */ if (principal == 0) revert IPool.InvalidParameters(); /* Validate duration is non-zero */ if (duration == 0) revert IPool.UnsupportedLoanDuration(); /* Validate repayment */ if (repayment > maxRepayment) revert IPool.RepaymentTooHigh(); /* Build the loan receipt */ LoanReceipt.LoanReceiptV2 memory receipt = LoanReceipt.LoanReceiptV2({ version: 2, principal: principal, repayment: repayment, adminFee: adminFee, borrower: msg.sender, maturity: (block.timestamp + duration).toUint64(), duration: duration, collateralToken: collateralToken, collateralTokenId: collateralTokenId, collateralWrapperContextLen: collateralWrapperContext.length.toUint16(), collateralWrapperContext: collateralWrapperContext, nodeReceipts: new LoanReceipt.NodeReceipt[](count) }); /* Use liquidity nodes */ for (uint256 i; i < count; i++) { /* Use node */ self.liquidity.use(nodes[i].tick, nodes[i].used, nodes[i].pending, duration); /* Construct node receipt */ receipt.nodeReceipts[i] = LoanReceipt.NodeReceipt({ tick: nodes[i].tick, used: nodes[i].used, pending: nodes[i].pending }); } /* Encode and hash the loan receipt */ bytes memory encodedLoanReceipt = LoanReceipt.encode(receipt); bytes32 loanReceiptHash = LoanReceipt.hash(encodedLoanReceipt); /* Validate no loan receipt hash collision */ if (self.loans[loanReceiptHash] != Pool.LoanStatus.Uninitialized) revert IPool.InvalidLoanReceipt(); /* Store loan status */ self.loans[loanReceiptHash] = Pool.LoanStatus.Active; return (encodedLoanReceipt, loanReceiptHash); } /** * @dev Helper function to handle repay accounting * @param self Pool storage * @param encodedLoanReceipt Encoded loan receipt * @return Repayment amount in currency tokens, decoded loan receipt, loan * receipt hash */ function _repay( Pool.PoolStorage storage self, bytes calldata encodedLoanReceipt ) external returns (uint256, LoanReceipt.LoanReceiptV2 memory, bytes32) { /* Compute loan receipt hash */ bytes32 loanReceiptHash = LoanReceipt.hash(encodedLoanReceipt); /* Validate loan receipt */ if (self.loans[loanReceiptHash] != Pool.LoanStatus.Active) revert IPool.InvalidLoanReceipt(); /* Decode loan receipt */ LoanReceipt.LoanReceiptV2 memory loanReceipt = LoanReceipt.decode(encodedLoanReceipt); /* Validate borrow and repay is not in same block */ if (loanReceipt.maturity - loanReceipt.duration == block.timestamp) revert IPool.InvalidLoanReceipt(); /* Validate caller is borrower */ if (msg.sender != loanReceipt.borrower) revert IPool.InvalidCaller(); /* Compute proration and repayment using prorated interest */ (uint256 repayment, uint256 proration) = _prorateRepayment(loanReceipt); /* Compute elapsed time since loan origination */ uint64 elapsed = uint64(block.timestamp + loanReceipt.duration - loanReceipt.maturity); /* Restore liquidity nodes */ for (uint256 i; i < loanReceipt.nodeReceipts.length; i++) { /* Restore node */ self.liquidity.restore( loanReceipt.nodeReceipts[i].tick, loanReceipt.nodeReceipts[i].used, loanReceipt.nodeReceipts[i].pending, loanReceipt.nodeReceipts[i].used + uint128( ((loanReceipt.nodeReceipts[i].pending - loanReceipt.nodeReceipts[i].used) * proration) / LiquidityLogic.FIXED_POINT_SCALE ), loanReceipt.duration, elapsed ); } /* Update admin fee total balance with prorated admin fee */ self.adminFeeBalance += (loanReceipt.adminFee * proration) / LiquidityLogic.FIXED_POINT_SCALE; /* Mark loan status repaid */ self.loans[loanReceiptHash] = Pool.LoanStatus.Repaid; return (repayment, loanReceipt, loanReceiptHash); } /** * @dev Helper function to handle liquidate accounting * @param self Pool storage * @param encodedLoanReceipt Encoded loan receipt * @return Decoded loan receipt, loan receipt hash */ function _liquidate( Pool.PoolStorage storage self, bytes calldata encodedLoanReceipt ) external returns (LoanReceipt.LoanReceiptV2 memory, bytes32) { /* Compute loan receipt hash */ bytes32 loanReceiptHash = LoanReceipt.hash(encodedLoanReceipt); /* Validate loan status is active */ if (self.loans[loanReceiptHash] != Pool.LoanStatus.Active) revert IPool.InvalidLoanReceipt(); /* Decode loan receipt */ LoanReceipt.LoanReceiptV2 memory loanReceipt = LoanReceipt.decode(encodedLoanReceipt); /* Validate loan is expired */ if (block.timestamp <= loanReceipt.maturity) revert IPool.LoanNotExpired(); /* Mark loan status liquidated */ self.loans[loanReceiptHash] = Pool.LoanStatus.Liquidated; return (loanReceipt, loanReceiptHash); } /** * @dev Helper function to handle collateral liquidation accounting * @param self Pool storage * @param encodedLoanReceipt Encoded loan receipt * @param proceeds Proceeds amount in currency tokens * @return Borrower surplus, decoded loan receipt, loan receipt hash */ function _onCollateralLiquidated( Pool.PoolStorage storage self, bytes calldata encodedLoanReceipt, uint256 proceeds ) external returns (uint256, LoanReceipt.LoanReceiptV2 memory, bytes32) { /* Compute loan receipt hash */ bytes32 loanReceiptHash = LoanReceipt.hash(encodedLoanReceipt); /* Validate loan status is liquidated */ if (self.loans[loanReceiptHash] != Pool.LoanStatus.Liquidated) revert IPool.InvalidLoanReceipt(); /* Decode loan receipt */ LoanReceipt.LoanReceiptV2 memory loanReceipt = LoanReceipt.decode(encodedLoanReceipt); /* Compute borrower's share of liquidation surplus */ uint256 borrowerSurplus = proceeds > loanReceipt.repayment ? proceeds - loanReceipt.repayment : 0; /* Compute elapsed time since loan origination */ uint64 elapsed = uint64(block.timestamp + loanReceipt.duration - loanReceipt.maturity); /* Restore liquidity nodes */ uint256 proceedsRemaining = proceeds - borrowerSurplus; uint256 lastIndex = loanReceipt.nodeReceipts.length - 1; for (uint256 i; i < loanReceipt.nodeReceipts.length; i++) { /* Compute amount to restore depending on whether there is a surplus */ uint256 restored = (i == lastIndex) ? proceedsRemaining : Math.min(loanReceipt.nodeReceipts[i].pending, proceedsRemaining); /* Restore node */ self.liquidity.restore( loanReceipt.nodeReceipts[i].tick, loanReceipt.nodeReceipts[i].used, loanReceipt.nodeReceipts[i].pending, restored.toUint128(), loanReceipt.duration, elapsed ); /* Update proceeds remaining */ proceedsRemaining -= restored; } /* Mark loan status collateral liquidated */ self.loans[loanReceiptHash] = Pool.LoanStatus.CollateralLiquidated; return (borrowerSurplus, loanReceipt, loanReceiptHash); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Collateral Filter API * @author MetaStreet Labs */ abstract contract CollateralFilter { /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid parameters */ error InvalidCollateralFilterParameters(); /**************************************************************************/ /* API */ /**************************************************************************/ /** * @notice Get collateral filter name * @return Collateral filter name */ function COLLATERAL_FILTER_NAME() external view virtual returns (string memory); /** * @notice Get collateral filter version * @return Collateral filter version */ function COLLATERAL_FILTER_VERSION() external view virtual returns (string memory); /** * @notice Get collateral token * @return Collateral token contract */ function collateralToken() external view virtual returns (address); /** * @notice Get collateral tokens * @return Collateral token contract */ function collateralTokens() external view virtual returns (address[] memory); /** * Query if collateral token is supported * @param token Collateral token contract * @param tokenId Collateral Token ID * @param index Collateral Token ID index * @param context ABI-encoded context * @return True if supported, otherwise false */ function _collateralSupported( address token, uint256 tokenId, uint256 index, bytes calldata context ) internal view virtual returns (bool); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import "./CollateralFilter.sol"; /** * @title Collection Collateral Filter * @author MetaStreet Labs */ contract CollectionCollateralFilter is CollateralFilter { using EnumerableSet for EnumerableSet.AddressSet; /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Supported token */ address private _token; /** * @notice Requires migration boolean */ bool private _requiresMigration; /** * @notice Set of supported aliases */ EnumerableSet.AddressSet private _aliases; /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice CollectionCollateralFilter initializer */ function _initialize(address[] memory tokens) internal { if (tokens.length == 0) revert InvalidCollateralFilterParameters(); _token = tokens[0]; for (uint256 i = 1; i < tokens.length; i++) { _aliases.add(tokens[i]); } } /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc CollateralFilter */ function COLLATERAL_FILTER_NAME() external pure override returns (string memory) { return "CollectionCollateralFilter"; } /** * @inheritdoc CollateralFilter */ function COLLATERAL_FILTER_VERSION() external pure override returns (string memory) { return "1.0"; } /** * @inheritdoc CollateralFilter */ function collateralToken() external view override returns (address) { return _token; } /** * @inheritdoc CollateralFilter */ function collateralTokens() external view override returns (address[] memory) { address[] memory aliases = _aliases.values(); address[] memory tokens = new address[](1 + aliases.length); /* Assign collateral token to first index in array */ tokens[0] = _token; /* Fill the array with aliases */ for (uint256 i; i < aliases.length; i++) { tokens[i + 1] = aliases[i]; } return tokens; } /** * @inheritdoc CollateralFilter */ function _collateralSupported( address token, uint256, uint256, bytes calldata ) internal view override returns (bool) { return token == _token || _aliases.contains(token); } /**************************************************************************/ /* Migration */ /**************************************************************************/ /** * @notice Set _requiresMigration, previously _initialized, to false. * @dev This function is to be removed after migration */ function migrate() external { require(_requiresMigration, "Already migrated"); _requiresMigration = false; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol"; import "./CollateralFilter.sol"; /** * @title Merkle Collection Collateral Filter * @author MetaStreet Labs */ contract MerkleCollectionCollateralFilter is CollateralFilter { /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid context */ error InvalidContext(); /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Supported token */ address private _token; /** * @notice Length of proof (multiple of 32) */ uint32 private _proofLength; /** * @notice Merkle root */ bytes32 private _root; /** * @notice Metadata URI */ string private _metadataURI; /** * @notice Requires migration boolean */ bool private _requiresMigration; /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice MerkleCollectionCollateralFilter initializer */ function _initialize(address token, bytes32 root, uint32 nodeCount, string memory metadataURI_) internal { /* Validate root */ if (root == bytes32(0)) revert InvalidCollateralFilterParameters(); /* Validate node count */ if (nodeCount == 0) revert InvalidCollateralFilterParameters(); _token = token; _root = root; _proofLength = nodeCount * 32; _metadataURI = metadataURI_; } /**************************************************************************/ /* Helpers */ /**************************************************************************/ /** * @notice Helper function that returns merkle proof in bytes32[] shape * @param proofData Proof data * @return merkleProof Merkle proof */ function _extractProof(bytes calldata proofData) internal pure returns (bytes32[] memory) { /* Compute node count */ uint256 nodeCount = (bytes32(proofData[proofData.length - 32:]) == bytes32(0)) ? proofData.length / 32 - 1 : proofData.length / 32; /* Instantiate merkle proof array */ bytes32[] memory merkleProof = new bytes32[](nodeCount); /* Populate merkle proof array */ for (uint256 i; i < nodeCount; i++) { /* Set node */ merkleProof[i] = bytes32(proofData[i * 32:]); } return merkleProof; } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @inheritdoc CollateralFilter */ function COLLATERAL_FILTER_NAME() external pure override returns (string memory) { return "MerkleCollectionCollateralFilter"; } /** * @inheritdoc CollateralFilter */ function COLLATERAL_FILTER_VERSION() external pure override returns (string memory) { return "1.0"; } /** * @notice Get collateral token * @return Collateral token contract */ function collateralToken() external view override returns (address) { return _token; } /** * @inheritdoc CollateralFilter */ function collateralTokens() external view override returns (address[] memory) { address[] memory tokens = new address[](1); tokens[0] = _token; return tokens; } /** * @notice Get merkle root * @return Merkle root */ function merkleRoot() external view returns (bytes32) { return _root; } /** * @notice Get metadata URI * @return Metadata URI */ function metadataURI() external view returns (string memory) { return _metadataURI; } /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc CollateralFilter */ function _collateralSupported( address token, uint256 tokenId, uint256 index, bytes calldata context ) internal view override returns (bool) { /* Validate token supported */ if (token != _token) return false; /* Compute proof offset */ uint32 proofLength = _proofLength; uint256 proofOffset = index * proofLength; /* Validate context length */ if (context.length < proofOffset + proofLength) revert InvalidContext(); /* Compute leaf hash */ bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(tokenId)))); return MerkleProof.verify(_extractProof(context[proofOffset:proofOffset + proofLength]), _root, leaf); } /**************************************************************************/ /* Migration */ /**************************************************************************/ /** * @notice Set _requiresMigration, previously _initialized, to false * @dev This function is to be removed after migration */ function migrate() external { require(_requiresMigration, "Already migrated"); _requiresMigration = false; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "./CollateralFilter.sol"; /** * @title Ranged Collection Collateral Filter * @author MetaStreet Labs */ contract RangedCollectionCollateralFilter is CollateralFilter { /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Supported token */ address private _token; /** * @notice Supported start token ID (inclusive) */ uint256 private _startTokenId; /** * @notice Supported end token ID (inclusive) */ uint256 private _endTokenId; /** * @notice Requires migration boolean */ bool private _requiresMigration; /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice RangedCollectionCollateralFilter initializer */ function _initialize(address token, uint256 startTokenId, uint256 endTokenId) internal { if (endTokenId < startTokenId) revert InvalidCollateralFilterParameters(); _token = token; _startTokenId = startTokenId; _endTokenId = endTokenId; } /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc CollateralFilter */ function COLLATERAL_FILTER_NAME() external pure override returns (string memory) { return "RangedCollectionCollateralFilter"; } /** * @inheritdoc CollateralFilter */ function COLLATERAL_FILTER_VERSION() external pure override returns (string memory) { return "1.0"; } /** * @inheritdoc CollateralFilter */ function collateralToken() external view override returns (address) { return _token; } /** * @inheritdoc CollateralFilter */ function collateralTokens() external view override returns (address[] memory) { address[] memory tokens = new address[](1); tokens[0] = _token; return tokens; } /** * @notice Get collateral token ID range * @return Start token ID (inclusive) * @return End token ID (inclusive) */ function collateralTokenIdRange() external view returns (uint256, uint256) { return (_startTokenId, _endTokenId); } /** * @inheritdoc CollateralFilter */ function _collateralSupported( address token, uint256 tokenId, uint256, bytes calldata ) internal view override returns (bool) { return token == _token && tokenId >= _startTokenId && tokenId <= _endTokenId; } /**************************************************************************/ /* Migration */ /**************************************************************************/ /** * @notice Set _requiresMigration, previously _initialized, to false * @dev This function is to be removed after migration */ function migrate() external { require(_requiresMigration, "Already migrated"); _requiresMigration = false; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import "./CollateralFilter.sol"; /** * @title Set Collection Collateral Filter * @author MetaStreet Labs */ contract SetCollectionCollateralFilter is CollateralFilter { using EnumerableSet for EnumerableSet.UintSet; /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Supported token */ address private _token; /** * @notice Set of supported token IDs */ EnumerableSet.UintSet private _tokenIds; /** * @notice Requires migration boolean */ bool private _requiresMigration; /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice SetCollectionCollateralFilter initializer */ function _initialize(address token, uint256[] memory tokenIds_) internal { /* Validate root and node count */ if (tokenIds_.length == 0) revert InvalidCollateralFilterParameters(); /* Set supported token */ _token = token; /* Add each token ID to set of token IDs */ for (uint256 i; i < tokenIds_.length; i++) { _tokenIds.add(tokenIds_[i]); } } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @inheritdoc CollateralFilter */ function COLLATERAL_FILTER_NAME() external pure override returns (string memory) { return "SetCollectionCollateralFilter"; } /** * @inheritdoc CollateralFilter */ function COLLATERAL_FILTER_VERSION() external pure override returns (string memory) { return "1.0"; } /** * @notice Get collateral token * @return Collateral token contract */ function collateralToken() external view override returns (address) { return _token; } /** * @inheritdoc CollateralFilter */ function collateralTokens() external view override returns (address[] memory) { address[] memory tokens = new address[](1); tokens[0] = _token; return tokens; } /** * @notice Get collateral token IDs * @return Collateral token IDs */ function collateralTokenIds() external view returns (uint256[] memory) { return _tokenIds.values(); } /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc CollateralFilter */ function _collateralSupported( address token, uint256 tokenId, uint256, bytes calldata ) internal view override returns (bool) { /* Validate token supported */ if (token != _token) return false; /* Validate token ID is in set of token IDs */ return _tokenIds.contains(tokenId); } /**************************************************************************/ /* Migration */ /**************************************************************************/ /** * @notice Set _requiresMigration, previously _initialized, to false * @dev This function is to be removed after migration */ function migrate() external { require(_requiresMigration, "Already migrated"); _requiresMigration = false; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface ICryptoPunksMarket { function punkIndexToAddress(uint256 punkIndex) external view returns (address owner); function balanceOf(address owner) external view returns (uint256 balance); function transferPunk(address to, uint256 punkIndex) external; function buyPunk(uint256 punkIndex) external payable; function offerPunkForSaleToAddress(uint256 punkIndex, uint256 minSalePriceInWei, address to) external; }
// SPDX-License-Identifier: CC0-1.0 pragma solidity ^0.8.19; /** * @title IDelegateRegistryV1 * * @dev Subset of full interface */ interface IDelegateRegistryV1 { /// @notice Delegation type enum DelegationType { NONE, ALL, CONTRACT, TOKEN } /// @notice Info about a single delegation, used for onchain enumeration struct DelegationInfo { DelegationType type_; address vault; address delegate; address contract_; uint256 tokenId; } /// @notice Info about a single contract-level delegation struct ContractDelegation { address contract_; address delegate; } /// @notice Info about a single token-level delegation struct TokenDelegation { address contract_; uint256 tokenId; address delegate; } /// @notice Emitted when a user delegates a specific token event DelegateForToken(address vault, address delegate, address contract_, uint256 tokenId, bool value); /** * ----------- WRITE ----------- */ /** * @notice Allow the delegate to act on your behalf for a specific token * @param delegate The hotwallet to act on your behalf * @param contract_ The address for the contract you're delegating * @param tokenId The token id for the token you're delegating * @param value Whether to enable or disable delegation for this address, true for setting and false for revoking */ function delegateForToken(address delegate, address contract_, uint256 tokenId, bool value) external; /** * ----------- READ ----------- */ /** * @notice Returns an array of contract-level delegates for a given vault's token * @param vault The cold wallet who issued the delegation * @param contract_ The address for the contract holding the token * @param tokenId The token id for the token you're delegating * @return addresses Array of contract-level delegates for a given vault's token */ function getDelegatesForToken( address vault, address contract_, uint256 tokenId ) external view returns (address[] memory); /** * @notice Returns true if the address is delegated to act on the entire vault * @param delegate The hotwallet to act on your behalf * @param vault The cold wallet who issued the delegation */ function checkDelegateForAll(address delegate, address vault) external view returns (bool); /** * @notice Returns true if the address is delegated to act on your behalf for a token contract or an entire vault * @param delegate The hotwallet to act on your behalf * @param contract_ The address for the contract you're delegating * @param vault The cold wallet who issued the delegation */ function checkDelegateForContract(address delegate, address vault, address contract_) external view returns (bool); /** * @notice Returns true if the address is delegated to act on your behalf for a specific token, the token's contract or an entire vault * @param delegate The hotwallet to act on your behalf * @param contract_ The address for the contract you're delegating * @param tokenId The token id for the token you're delegating * @param vault The cold wallet who issued the delegation */ function checkDelegateForToken( address delegate, address vault, address contract_, uint256 tokenId ) external view returns (bool); }
// SPDX-License-Identifier: CC0-1.0 pragma solidity >=0.8.13; /** * @title IDelegateRegistryV2 * * @dev Subset of full interface * * @author foobar (0xfoobar) */ interface IDelegateRegistryV2 { /// @notice Delegation type, NONE is used when a delegation does not exist or is revoked enum DelegationType { NONE, ALL, CONTRACT, ERC721, ERC20, ERC1155 } /// @notice Struct for returning delegations struct Delegation { DelegationType type_; address to; address from; bytes32 rights; address contract_; uint256 tokenId; uint256 amount; } /// @notice Emitted when an address delegates or revokes rights for an ERC721 tokenId event DelegateERC721( address indexed from, address indexed to, address indexed contract_, uint256 tokenId, bytes32 rights, bool enable ); /** * ----------- WRITE ----------- */ /** * @notice Allow the delegate to act on behalf of `msg.sender` for a specific ERC721 token * @param to The address to act as delegate * @param contract_ The contract whose rights are being delegated * @param tokenId The token id to delegate * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights * @param enable Whether to enable or disable this delegation, true delegates and false revokes * @return delegationHash The unique identifier of the delegation */ function delegateERC721( address to, address contract_, uint256 tokenId, bytes32 rights, bool enable ) external payable returns (bytes32 delegationHash); /** * @notice Check if `to` is a delegate of `from` for the specific `contract` and `tokenId`, the entire `contract_`, or the entire wallet * @param to The delegated address to check * @param contract_ The specific contract address being checked * @param tokenId The token id for the token to delegating * @param from The wallet that issued the delegation * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only * @return valid Whether delegate is granted to act on from's behalf for entire wallet, that contract, or that specific tokenId */ function checkDelegateForERC721( address to, address from, address contract_, uint256 tokenId, bytes32 rights ) external view returns (bool); /** * ----------- ENUMERATIONS ----------- */ /** * @notice Returns all enabled delegations an address has given out * @param from The address to retrieve delegations for * @return delegations Array of Delegation structs */ function getOutgoingDelegations(address from) external view returns (Delegation[] memory delegations); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Interface to a Collateral Liquidation Receiver */ interface ICollateralLiquidationReceiver { /** * @notice Callback on collateral liquidated * @dev Pre-conditions: 1) proceeds were transferred, and 2) transferred amount >= proceeds * @param liquidationContext Liquidation context * @param proceeds Liquidation proceeds in currency tokens */ function onCollateralLiquidated(bytes calldata liquidationContext, uint256 proceeds) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Interface to a Collateral Liquidator */ interface ICollateralLiquidator { /** * @notice Get collateral liquidator name * @return Collateral liquidator name */ function name() external view returns (string memory); /** * @notice Liquidate collateral * @param currencyToken Currency token * @param collateralToken Collateral token, either underlying token or collateral wrapper * @param collateralTokenId Collateral token ID * @param collateralWrapperContext Collateral wrapper context * @param liquidationContext Liquidation callback context */ function liquidate( address currencyToken, address collateralToken, uint256 collateralTokenId, bytes calldata collateralWrapperContext, bytes calldata liquidationContext ) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Interface to a Collateral Wrapper */ interface ICollateralWrapper { /**************************************************************************/ /* API */ /**************************************************************************/ /** * @notice Get collateral wrapper name * @return Collateral wrapper name */ function name() external view returns (string memory); /** * @notice Enumerate wrapped collateral * @param tokenId Collateral wrapper token ID * @param context Implementation-specific context * @return token Token address * @return tokenIds List of unique token ids */ function enumerate( uint256 tokenId, bytes calldata context ) external view returns (address token, uint256[] memory tokenIds); /** * @notice Enumerate wrapped collateral with quantities of each token id * @param tokenId Collateral wrapper token ID * @param context Implementation-specific context * @return token Token address * @return tokenIds List of unique token ids * @return quantities List of quantities of each token id */ function enumerateWithQuantities( uint256 tokenId, bytes calldata context ) external view returns (address token, uint256[] memory tokenIds, uint256[] memory quantities); /** * @notice Get total token count represented by wrapped collateral * @param tokenId Collateral wrapper token ID * @param context Implementation-specific context * @return tokenCount Total token count */ function count(uint256 tokenId, bytes calldata context) external view returns (uint256 tokenCount); /* * Transfer collateral calldata * @param token Collateral token * @param from From address * @param to To address * @param tokenId Collateral wrapper token ID * @param quantity Quantity of token ID * @return target Transfer target * @return data Transfer calldata */ function transferCalldata( address token, address from, address to, uint256 tokenId, uint256 quantity ) external returns (address target, bytes memory data); /* * Unwrap collateral * @param tokenId Collateral wrapper token ID * @param context Implementation-specific context */ function unwrap(uint256 tokenId, bytes calldata context) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Interface to Liquidity state */ interface ILiquidity { /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Insufficient liquidity */ error InsufficientLiquidity(); /** * @notice Inactive liquidity */ error InactiveLiquidity(); /** * @notice Insufficient tick spacing */ error InsufficientTickSpacing(); /**************************************************************************/ /* Structures */ /**************************************************************************/ /** * @notice Flattened liquidity node returned by getter * @param tick Tick * @param value Liquidity value * @param shares Liquidity shares outstanding * @param available Liquidity available * @param pending Liquidity pending (with interest) * @param redemptions Total pending redemptions * @param prev Previous liquidity node * @param next Next liquidity node */ struct NodeInfo { uint128 tick; uint128 value; uint128 shares; uint128 available; uint128 pending; uint128 redemptions; uint128 prev; uint128 next; } /** * @notice Accrual info returned by getter * @param accrued Accrued interest * @param rate Accrual rate * @param timestamp Accrual timestamp */ struct AccrualInfo { uint128 accrued; uint64 rate; uint64 timestamp; } /**************************************************************************/ /* API */ /**************************************************************************/ /** * Get liquidity nodes spanning [startTick, endTick] range * @param startTick Start tick * @param endTick End tick * @return Liquidity nodes */ function liquidityNodes(uint128 startTick, uint128 endTick) external view returns (NodeInfo[] memory); /** * Get liquidity node at tick * @param tick Tick * @return Liquidity node */ function liquidityNode(uint128 tick) external view returns (NodeInfo memory); /** * Get liquidity node with accrual info at tick * @param tick Tick * @return Liquidity node, Accrual info */ function liquidityNodeWithAccrual(uint128 tick) external view returns (NodeInfo memory, AccrualInfo memory); /** * @notice Get deposit share price * @param tick Tick * @return Deposit share price */ function depositSharePrice(uint128 tick) external view returns (uint256); /** * @notice Get redemption share price * @param tick Tick * @return Redemption share price */ function redemptionSharePrice(uint128 tick) external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Interface to a Pool */ interface IPool { /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid caller */ error InvalidCaller(); /** * @notice Insufficient shares */ error InsufficientShares(); /** * @notice Invalid redemption status */ error InvalidRedemptionStatus(); /** * @notice Invalid loan receipt */ error InvalidLoanReceipt(); /** * @notice Invalid borrow options */ error InvalidBorrowOptions(); /** * @notice Unsupported collateral * @param index Index of unsupported asset */ error UnsupportedCollateral(uint256 index); /** * @notice Unsupported loan duration */ error UnsupportedLoanDuration(); /** * @notice Repayment too high */ error RepaymentTooHigh(); /** * @notice Loan not expired */ error LoanNotExpired(); /** * @notice Invalid parameters */ error InvalidParameters(); /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when currency is deposited * @param account Account * @param tick Tick * @param amount Amount of currency tokens * @param shares Amount of shares allocated */ event Deposited(address indexed account, uint128 indexed tick, uint256 amount, uint256 shares); /** * @notice Emitted when deposit shares are redeemed * @param account Account * @param tick Tick * @param redemptionId Redemption ID * @param shares Amount of shares to be redeemed */ event Redeemed(address indexed account, uint128 indexed tick, uint128 indexed redemptionId, uint256 shares); /** * @notice Emitted when redeemed currency tokens are withdrawn * @param account Account * @param tick Tick * @param redemptionId Redemption ID * @param shares Amount of shares redeemed * @param amount Amount of currency tokens withdrawn */ event Withdrawn( address indexed account, uint128 indexed tick, uint128 indexed redemptionId, uint256 shares, uint256 amount ); /** * @notice Emitted when deposit shares are transferred * @param from Source account * @param to Destination account * @param tick Tick * @param shares Amount of shares transferred */ event Transferred(address indexed from, address indexed to, uint128 indexed tick, uint256 shares); /** * @notice Emitted when a loan is originated * @param loanReceiptHash Loan receipt hash * @param loanReceipt Loan receipt */ event LoanOriginated(bytes32 indexed loanReceiptHash, bytes loanReceipt); /** * @notice Emitted when a loan is repaid * @param loanReceiptHash Loan receipt hash * @param repayment Repayment amount in currency tokens */ event LoanRepaid(bytes32 indexed loanReceiptHash, uint256 repayment); /** * @notice Emitted when a loan is liquidated * @param loanReceiptHash Loan receipt hash */ event LoanLiquidated(bytes32 indexed loanReceiptHash); /** * @notice Emitted when loan collateral is liquidated * @param loanReceiptHash Loan receipt hash * @param proceeds Total liquidation proceeds in currency tokens * @param borrowerProceeds Borrower's share of liquidation proceeds in * currency tokens */ event CollateralLiquidated(bytes32 indexed loanReceiptHash, uint256 proceeds, uint256 borrowerProceeds); /** * @notice Emitted when admin fee rate is updated * @param rate New admin fee rate in basis points */ event AdminFeeRateUpdated(uint256 rate); /** * @notice Emitted when admin fees are withdrawn * @param account Recipient account * @param amount Amount of currency tokens withdrawn */ event AdminFeesWithdrawn(address indexed account, uint256 amount); /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @notice Get currency token * @return Currency token contract */ function currencyToken() external view returns (address); /** * @notice Get supported durations * @return List of loan durations in second */ function durations() external view returns (uint64[] memory); /** * @notice Get supported rates * @return List of rates in interest per second */ function rates() external view returns (uint64[] memory); /** * @notice Get admin * @return Admin */ function admin() external view returns (address); /** * @notice Get admin fee rate * @return Admin fee rate in basis points */ function adminFeeRate() external view returns (uint32); /** * @notice Get admin fee balance * @return Admin fee balance in currency tokens */ function adminFeeBalance() external view returns (uint256); /** * @notice Get list of supported collateral wrappers * @return Collateral wrappers */ function collateralWrappers() external view returns (address[] memory); /** * @notice Get collateral liquidator contract * @return Collateral liquidator contract */ function collateralLiquidator() external view returns (address); /** * @notice Get delegation registry v1 contract * @return Delegation registry contract */ function delegationRegistry() external view returns (address); /** * @notice Get delegation registry v2 contract * @return Delegation registry contract */ function delegationRegistryV2() external view returns (address); /**************************************************************************/ /* Deposit API */ /**************************************************************************/ /** * @notice Deposit amount at tick * * Emits a {Deposited} event. * * @param tick Tick * @param amount Amount of currency tokens * @param minShares Minimum amount of shares to receive * @return shares Amount of shares minted */ function deposit(uint128 tick, uint256 amount, uint256 minShares) external returns (uint256 shares); /** * @notice Redeem deposit shares for currency tokens. Currency tokens can * be withdrawn with the `withdraw()` method once the redemption is * processed. * * Emits a {Redeemed} event. * * @param tick Tick * @param shares Amount of deposit shares to redeem * @return redemptionId Redemption ID */ function redeem(uint128 tick, uint256 shares) external returns (uint128 redemptionId); /** * @notice Get redemption available * * @param account Account * @param tick Tick * @param redemptionId Redemption ID * @return shares Amount of deposit shares available for redemption * @return amount Amount of currency tokens available for withdrawal * @return sharesAhead Amount of pending shares ahead in queue */ function redemptionAvailable( address account, uint128 tick, uint128 redemptionId ) external view returns (uint256 shares, uint256 amount, uint256 sharesAhead); /** * @notice Withdraw a redemption that is available * * Emits a {Withdrawn} event. * * @param tick Tick * @param redemptionId Redemption ID * @return shares Amount of deposit shares burned * @return amount Amount of currency tokens withdrawn */ function withdraw(uint128 tick, uint128 redemptionId) external returns (uint256 shares, uint256 amount); /** * @notice Rebalance a redemption that is available to a new tick * * Emits {Withdrawn} and {Deposited} events. * * @param srcTick Source tick * @param dstTick Destination Tick * @param redemptionId Redemption ID * @param minShares Minimum amount of destination shares to receive * @return oldShares Amount of source deposit shares burned * @return newShares Amount of destination deposit shares minted * @return amount Amount of currency tokens redeposited */ function rebalance( uint128 srcTick, uint128 dstTick, uint128 redemptionId, uint256 minShares ) external returns (uint256 oldShares, uint256 newShares, uint256 amount); /**************************************************************************/ /* Lend API */ /**************************************************************************/ /** * @notice Quote repayment for a loan * @param principal Principal amount in currency tokens * @param duration Duration in seconds * @param collateralToken Collateral token address * @param collateralTokenId Collateral token ID * @param ticks Liquidity ticks * @param options Encoded options * @return repayment Repayment amount in currency tokens */ function quote( uint256 principal, uint64 duration, address collateralToken, uint256 collateralTokenId, uint128[] calldata ticks, bytes calldata options ) external view returns (uint256 repayment); /** * @notice Originate a loan * * Emits a {LoanOriginated} event. * * @param principal Principal amount in currency tokens * @param duration Duration in seconds * @param collateralToken Collateral token address * @param collateralTokenId Collateral token ID * @param maxRepayment Maximum repayment amount in currency tokens * @param ticks Liquidity ticks * @param options Encoded options * @return repayment Repayment amount in currency tokens */ function borrow( uint256 principal, uint64 duration, address collateralToken, uint256 collateralTokenId, uint256 maxRepayment, uint128[] calldata ticks, bytes calldata options ) external returns (uint256 repayment); /** * @notice Repay a loan * * Emits a {LoanRepaid} event. * * @param encodedLoanReceipt Encoded loan receipt * @return repayment Repayment amount in currency tokens */ function repay(bytes calldata encodedLoanReceipt) external returns (uint256 repayment); /** * @notice Refinance a loan * * Emits a {LoanRepaid} event and a {LoanOriginated} event. * * @param encodedLoanReceipt Encoded loan receipt * @param principal Principal amount in currency tokens * @param duration Duration in seconds * @param maxRepayment Maximum repayment amount in currency tokens * @param ticks Liquidity ticks * @return repayment Repayment amount in currency tokens */ function refinance( bytes calldata encodedLoanReceipt, uint256 principal, uint64 duration, uint256 maxRepayment, uint128[] calldata ticks ) external returns (uint256 repayment); /** * @notice Liquidate an expired loan * * Emits a {LoanLiquidated} event. * * @param loanReceipt Loan receipt */ function liquidate(bytes calldata loanReceipt) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Interface to the Pool Factory */ interface IPoolFactory { /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Unsupported Pool implementation */ error UnsupportedImplementation(); /** * @notice Invalid Pool */ error InvalidPool(); /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when a pool is created * @param pool Pool instance * @param implementation Implementation contract */ event PoolCreated(address indexed pool, address indexed implementation); /** * @notice Emitted when a pool implementation is added to allowlist * @param implementation Implementation contract */ event PoolImplementationAdded(address indexed implementation); /** * @notice Emitted when a pool implementation is removed from allowlist * @param implementation Implementation contract */ event PoolImplementationRemoved(address indexed implementation); /**************************************************************************/ /* API */ /**************************************************************************/ /** * Create a pool (immutable) * @param poolImplementation Pool implementation contract * @param params Pool parameters * @return Pool address */ function create(address poolImplementation, bytes calldata params) external returns (address); /** * Create a pool (proxied) * @param poolBeacon Pool beacon contract * @param params Pool parameters * @return Pool address */ function createProxied(address poolBeacon, bytes calldata params) external returns (address); /** * @notice Check if address is a pool * @param pool Pool address * @return True if address is a pool, otherwise false */ function isPool(address pool) external view returns (bool); /** * @notice Get list of pools * @return List of pool addresses */ function getPools() external view returns (address[] memory); /** * @notice Get count of pools * @return Count of pools */ function getPoolCount() external view returns (uint256); /** * @notice Get pool at index * @param index Index * @return Pool address */ function getPoolAt(uint256 index) external view returns (address); /** * @notice Get list of supported pool implementations * @return List of pool implementations */ function getPoolImplementations() external view returns (address[] memory); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/utils/Address.sol"; import "@openzeppelin/contracts/utils/math/Math.sol"; import "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol"; import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol"; import "../interfaces/ICollateralLiquidationReceiver.sol"; import "../interfaces/ICollateralLiquidator.sol"; import "../interfaces/ICollateralWrapper.sol"; /** * @title English Auction Collateral Liquidator * @author MetaStreet Labs */ contract EnglishAuctionCollateralLiquidator is ICollateralLiquidator, ReentrancyGuard, ERC1155Holder { using SafeERC20 for IERC20; /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Implementation version */ string public constant IMPLEMENTATION_VERSION = "2.0"; /** * @notice Basis points scale */ uint256 internal constant BASIS_POINTS_SCALE = 10_000; /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid parameters */ error InvalidParameters(); /** * @notice Invalid token */ error InvalidToken(); /** * @notice Invalid auction */ error InvalidAuction(); /** * @notice Invalid liquidation */ error InvalidLiquidation(); /** * @notice Invalid bid */ error InvalidBid(); /** * @notice Invalid collateral claim */ error InvalidClaim(); /**************************************************************************/ /* Structures */ /**************************************************************************/ /** * @notice Auction * @param quantity Quantity of token ID * @param endTime Auction end time * @param highestBidder Highest bidder * @param highestBid Highest bid */ struct Auction { uint256 quantity; uint64 endTime; address highestBidder; uint256 highestBid; } /** * @notice Liquidation * @param source Address the liquidation came from * @param currencyToken Currency token * @param collateralToken Collateral token * @param auctionCount Number of auctions that have not ended * @param liquidationContextHash Liquidation context hash * @param proceeds Proceeds from liquidations */ struct Liquidation { address source; address currencyToken; address collateralToken; uint16 auctionCount; bytes32 liquidationContextHash; uint256 proceeds; } /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when a liquidation is started * @param liquidationHash Liquidation hash * @param source Liquidation source * @param liquidationContextHash Liquidation context hash * @param currencyToken Currency token * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param auctionCount Auction count */ event LiquidationStarted( bytes32 indexed liquidationHash, address indexed source, bytes32 indexed liquidationContextHash, address currencyToken, address collateralToken, uint256 collateralTokenId, uint16 auctionCount ); /** * @notice Emitted when an auction is created * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param quantity Quantity of collateral token */ event AuctionCreated( bytes32 indexed liquidationHash, address indexed collateralToken, uint256 indexed collateralTokenId, uint256 quantity ); /** * @notice Emitted when an auction is started * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param endTime Auction end time */ event AuctionStarted( bytes32 indexed liquidationHash, address indexed collateralToken, uint256 indexed collateralTokenId, uint64 endTime ); /** * @notice Emitted when an auction is extended * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param endTime Auction end time */ event AuctionExtended( bytes32 indexed liquidationHash, address indexed collateralToken, uint256 indexed collateralTokenId, uint64 endTime ); /** * @notice Emitted when an auction receives a bid * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param bidder Bidder * @param amount Bid amount */ event AuctionBid( bytes32 indexed liquidationHash, address indexed collateralToken, uint256 indexed collateralTokenId, address bidder, uint256 amount ); /** * @notice Emitted when an auction is ended and collateral is claimed by winner * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param winner Winner of auction * @param proceeds Proceeds in currency tokens */ event AuctionEnded( bytes32 indexed liquidationHash, address indexed collateralToken, uint256 indexed collateralTokenId, address winner, uint256 proceeds ); /** * @notice Emitted when a liquidation is ended * @param liquidationHash Liquidation hash * @param proceeds Proceeds in currency tokens */ event LiquidationEnded(bytes32 indexed liquidationHash, uint256 proceeds); /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Initialized boolean */ bool private _initialized; /** * @notice Auction duration */ uint64 private _auctionDuration; /** * @notice Duration window before an auction's end time */ uint64 private _timeExtensionWindow; /** * @notice Time extension of auction when a new bid is made within _timeExtensionWindow */ uint64 private _timeExtension; /** * @notice Minimum bid increment from previous bid */ uint64 private _minimumBidBasisPoints; /** * @notice Collateral wrappers (max 5) */ address internal immutable _collateralWrapper1; address internal immutable _collateralWrapper2; address internal immutable _collateralWrapper3; address internal immutable _collateralWrapper4; address internal immutable _collateralWrapper5; /** * @dev Collateral auctions */ mapping(bytes32 => mapping(address => mapping(uint256 => Auction))) private _auctions; /** * @dev Liquidation tracker */ mapping(bytes32 => Liquidation) private _liquidations; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice EnglishAuctionCollateralLiquidator constructor */ constructor(address[] memory collateralWrappers_) { /* Validate number of collateral wrappers */ if (collateralWrappers_.length > 5) revert InvalidParameters(); /* Assign collateral wrappers */ _collateralWrapper1 = (collateralWrappers_.length > 0) ? collateralWrappers_[0] : address(0); _collateralWrapper2 = (collateralWrappers_.length > 1) ? collateralWrappers_[1] : address(0); _collateralWrapper3 = (collateralWrappers_.length > 2) ? collateralWrappers_[2] : address(0); _collateralWrapper4 = (collateralWrappers_.length > 3) ? collateralWrappers_[3] : address(0); _collateralWrapper5 = (collateralWrappers_.length > 4) ? collateralWrappers_[4] : address(0); /* Disable initialization of implementation contract */ _initialized = true; } /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice Initializer * @dev Fee-on-transfer currency tokens are not supported */ function initialize( uint64 auctionDuration_, uint64 timeExtensionWindow_, uint64 timeExtension_, uint64 minimumBidBasisPoints_ ) external { require(!_initialized, "Already initialized"); if (auctionDuration_ <= timeExtensionWindow_) revert InvalidParameters(); if (timeExtension_ <= timeExtensionWindow_) revert InvalidParameters(); if (auctionDuration_ == 0) revert InvalidParameters(); _initialized = true; _auctionDuration = auctionDuration_; _timeExtensionWindow = timeExtensionWindow_; _timeExtension = timeExtension_; _minimumBidBasisPoints = minimumBidBasisPoints_; } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @notice Get collateral wrappers * @return Collateral wrappers */ function collateralWrappers() external view returns (address[] memory) { address[] memory collateralWrappers_ = new address[](5); collateralWrappers_[0] = _collateralWrapper1; collateralWrappers_[1] = _collateralWrapper2; collateralWrappers_[2] = _collateralWrapper3; collateralWrappers_[3] = _collateralWrapper4; collateralWrappers_[4] = _collateralWrapper5; return collateralWrappers_; } /** * @notice Get auction duration * @return Auction duration */ function auctionDuration() external view returns (uint64) { return _auctionDuration; } /** * @notice Get time extension window * @return Time extension window */ function timeExtensionWindow() external view returns (uint64) { return _timeExtensionWindow; } /** * @notice Get time extension * @return Time extension */ function timeExtension() external view returns (uint64) { return _timeExtension; } /** * @notice Get minimum bid basis points * @return Minimum bid basis points */ function minimumBidBasisPoints() external view returns (uint64) { return _minimumBidBasisPoints; } /** * Get liquidation details * @param liquidationHash Liquidation hash * @return Liquidation Liquidation details */ function liquidations(bytes32 liquidationHash) external view returns (Liquidation memory) { return _liquidations[liquidationHash]; } /** * Get auction details * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @return Auction Auction details */ function auctions( bytes32 liquidationHash, address collateralToken, uint256 collateralTokenId ) external view returns (Auction memory) { return _auctions[liquidationHash][collateralToken][collateralTokenId]; } /**************************************************************************/ /* Helper Functions */ /**************************************************************************/ /** * @notice Helper function to check if collateral token is a collateral wrapper * @param collateralToken Collateral token */ function _isCollateralWrapper(address collateralToken) internal view returns (bool) { return collateralToken == _collateralWrapper1 || collateralToken == _collateralWrapper2 || collateralToken == _collateralWrapper3 || collateralToken == _collateralWrapper4 || collateralToken == _collateralWrapper5; } /** * @notice Helper function to compute liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID */ function _liquidationHash(address collateralToken, uint256 collateralTokenId) internal view returns (bytes32) { return keccak256(abi.encodePacked(block.chainid, collateralToken, collateralTokenId, block.timestamp)); } /** * @notice Helper function to compute liquidation context hash * @param liquidationContext Liquidation context */ function _liquidationContextHash(bytes calldata liquidationContext) internal view returns (bytes32) { return keccak256(abi.encodePacked(block.chainid, liquidationContext)); } /** * @notice Helper function to create an auction * * Emits a {AuctionCreated} event. * * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param quantity Quantity */ function _createAuction( bytes32 liquidationHash, address collateralToken, uint256 collateralTokenId, uint256 quantity ) internal { /* Create collateral auction */ _auctions[liquidationHash][collateralToken][collateralTokenId] = Auction({ quantity: quantity, endTime: 0, highestBidder: address(0), highestBid: 0 }); /* Emit AuctionCreated */ emit AuctionCreated(liquidationHash, collateralToken, collateralTokenId, quantity); } /** * @notice Helper function to process a collateral liquidation * * Emits a {CollateralLiquidated} event. * * @param auction_ Auction * @param liquidationHash Liquidation hash * @param liquidationContext Liquidation context * @return Collateral token */ function _processLiquidation( Auction memory auction_, bytes32 liquidationHash, bytes calldata liquidationContext ) internal returns (address) { /* Get liquidation */ Liquidation memory liquidation_ = _liquidations[liquidationHash]; /* Validate liquidation exists */ if (liquidation_.source == address(0)) revert InvalidClaim(); /* Validate liquidation context */ if (liquidation_.liquidationContextHash != _liquidationContextHash(liquidationContext)) revert InvalidClaim(); /* Liquidate if all auctions for the liquidation are completed */ if (liquidation_.auctionCount == 1) { /* Compute total proceeds */ uint256 proceeds = liquidation_.proceeds + auction_.highestBid; /* Delete liquidation since all auctions are completed */ delete _liquidations[liquidationHash]; /* Transfer proceeds from this contract to source */ IERC20(liquidation_.currencyToken).safeTransfer(liquidation_.source, proceeds); /* If source is a contract that implements ICollateralLiquidationReceiver, make collateral liquidation callback */ if ( Address.isContract(liquidation_.source) && ERC165Checker.supportsInterface(liquidation_.source, type(ICollateralLiquidationReceiver).interfaceId) ) ICollateralLiquidationReceiver(liquidation_.source).onCollateralLiquidated(liquidationContext, proceeds); /* Emit LiquidationEnded */ emit LiquidationEnded(liquidationHash, proceeds); } else { /* Update liquidation proceeds */ _liquidations[liquidationHash].proceeds += auction_.highestBid; /* Update liquidation active auctions */ _liquidations[liquidationHash].auctionCount -= 1; } return liquidation_.collateralToken; } /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc ICollateralLiquidator */ function name() external pure returns (string memory) { return "EnglishAuctionCollateralLiquidator"; } /** * @inheritdoc ICollateralLiquidator */ function liquidate( address currencyToken, address collateralToken, uint256 collateralTokenId, bytes calldata collateralWrapperContext, bytes calldata liquidationContext ) external nonReentrant { /* Check collateral token and currency token is not zero address */ if (collateralToken == address(0) || currencyToken == address(0)) revert InvalidToken(); /* Compute liquidation hash */ bytes32 liquidationHash = _liquidationHash(collateralToken, collateralTokenId); /* Validate liquidation does not exist */ if (_liquidations[liquidationHash].source != address(0)) revert InvalidLiquidation(); /* Declare underlying collateral token address and IDs */ address underlyingCollateralToken; uint256[] memory underlyingCollateralTokenIds; uint256[] memory underlyingQuantities; /* Cache check for collateral wrapper */ bool isCollateralWrapper = _isCollateralWrapper(collateralToken); /* Determine if collateral token is a whitelisted collateral wrapper */ if (isCollateralWrapper) { /* Get underlying collateral token, underlying collateral token IDs, and quantities of each token ID */ (underlyingCollateralToken, underlyingCollateralTokenIds, underlyingQuantities) = ICollateralWrapper( collateralToken ).enumerateWithQuantities(collateralTokenId, collateralWrapperContext); } else { /* Assign collateral token address and ID */ underlyingCollateralToken = collateralToken; underlyingCollateralTokenIds = new uint256[](1); underlyingCollateralTokenIds[0] = collateralTokenId; underlyingQuantities = new uint256[](1); underlyingQuantities[0] = 1; } /* Compute liquidation context hash */ bytes32 liquidationContextHash = _liquidationContextHash(liquidationContext); /* Emit LiquidationStarted */ emit LiquidationStarted( liquidationHash, msg.sender, liquidationContextHash, currencyToken, collateralToken, collateralTokenId, uint16(underlyingCollateralTokenIds.length) ); /* Iterate through underlying collaterals to create an auction for each underlying collateral */ for (uint16 i = 0; i < underlyingCollateralTokenIds.length; i++) { _createAuction( liquidationHash, underlyingCollateralToken, underlyingCollateralTokenIds[i], underlyingQuantities[i] ); } /* Create liquidation */ _liquidations[liquidationHash] = Liquidation({ source: msg.sender, currencyToken: currencyToken, collateralToken: collateralToken, auctionCount: uint16(underlyingCollateralTokenIds.length), liquidationContextHash: liquidationContextHash, proceeds: 0 }); /* Transfer collateral token from source to this contract */ IERC721(collateralToken).transferFrom(msg.sender, address(this), collateralTokenId); /* Unwrap if collateral token is a collateral wrapper */ if (isCollateralWrapper) ICollateralWrapper(collateralToken).unwrap(collateralTokenId, collateralWrapperContext); } /** * @notice Bid on an auction * * Emits a {AuctionBid} event. * * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param amount Bid amount */ function bid( bytes32 liquidationHash, address collateralToken, uint256 collateralTokenId, uint256 amount ) external nonReentrant { /* Get auction */ Auction memory auction_ = _auctions[liquidationHash][collateralToken][collateralTokenId]; /* Get liquidation */ Liquidation memory liquidation_ = _liquidations[liquidationHash]; /* Validate liquidation exists */ if (liquidation_.source == address(0)) revert InvalidAuction(); /* Validate that auction exists */ if (auction_.quantity == 0) revert InvalidAuction(); /* Validate auction has not ended */ if (auction_.endTime != 0 && auction_.endTime < uint64(block.timestamp)) revert InvalidBid(); /* Validate bid amount is bigger than the minimum bid amount */ if ( amount <= auction_.highestBid || amount - auction_.highestBid < (auction_.highestBid * _minimumBidBasisPoints) / BASIS_POINTS_SCALE ) revert InvalidBid(); /* If auction has not started */ if (auction_.endTime == 0) { /* Calculate end time */ uint64 endTime = uint64(block.timestamp) + _auctionDuration; /* Start auction */ _auctions[liquidationHash][collateralToken][collateralTokenId].endTime = endTime; /* Emit AuctionStarted */ emit AuctionStarted(liquidationHash, collateralToken, collateralTokenId, endTime); } else if (auction_.endTime - uint64(block.timestamp) <= _timeExtensionWindow) { /* Calculate new end time */ uint64 endTime = uint64(block.timestamp) + _timeExtension; /* Update end time if auction is already in progress and within * time extension window */ _auctions[liquidationHash][collateralToken][collateralTokenId].endTime = endTime; /* Emit AuctionExtended */ emit AuctionExtended(liquidationHash, collateralToken, collateralTokenId, endTime); } /* Update auction with new bid */ _auctions[liquidationHash][collateralToken][collateralTokenId].highestBidder = msg.sender; _auctions[liquidationHash][collateralToken][collateralTokenId].highestBid = amount; /* If not first bidder */ if (auction_.highestBidder != address(0)) { /* Transfer previous bid back from collateral liquidator to previous bidder */ IERC20(liquidation_.currencyToken).safeTransfer(auction_.highestBidder, auction_.highestBid); } /* Transfer bid amount from bidder to collateral liquidator */ IERC20(liquidation_.currencyToken).safeTransferFrom(msg.sender, address(this), amount); /* Emit AuctionBid */ emit AuctionBid(liquidationHash, collateralToken, collateralTokenId, msg.sender, amount); } /** * @notice Claim collateral and liquidate if possible * * Emits a {CollateralLiquidated} event. * Emits a {AuctionEnded} event. * * @param liquidationHash Liquidation hash * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param liquidationContext Liquidation context */ function claim( bytes32 liquidationHash, address collateralToken, uint256 collateralTokenId, bytes calldata liquidationContext ) external nonReentrant { /* Get auction */ Auction memory auction_ = _auctions[liquidationHash][collateralToken][collateralTokenId]; /* Validate that auction exists */ if (auction_.quantity == 0) revert InvalidAuction(); /* Validate that auction was started */ if (auction_.highestBidder == address(0)) revert InvalidClaim(); /* Validate that auction has ended */ if (uint64(block.timestamp) <= auction_.endTime) revert InvalidClaim(); /* Process liquidation proceeds */ address wrappedCollateralToken = _processLiquidation(auction_, liquidationHash, liquidationContext); /* Delete auction */ delete _auctions[liquidationHash][collateralToken][collateralTokenId]; /* Transfer collateral from contract to auction winner */ if (_isCollateralWrapper(wrappedCollateralToken)) { /* Get transfer call target and calldata */ (address target, bytes memory data) = ICollateralWrapper(wrappedCollateralToken).transferCalldata( collateralToken, address(this), auction_.highestBidder, collateralTokenId, auction_.quantity ); /* Transfer collateral */ (bool success, ) = target.call(data); /* Validate call success */ if (!success) revert InvalidClaim(); } else { IERC721(collateralToken).transferFrom(address(this), auction_.highestBidder, collateralTokenId); } /* Emit AuctionEnded */ emit AuctionEnded( liquidationHash, collateralToken, collateralTokenId, auction_.highestBidder, auction_.highestBid ); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/utils/math/Math.sol"; import "@openzeppelin/contracts/utils/math/SafeCast.sol"; import "./interfaces/ILiquidity.sol"; import "./Tick.sol"; /** * @title Liquidity Logic * @author MetaStreet Labs */ library LiquidityLogic { using SafeCast for uint256; /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Tick limit spacing basis points (10%) */ uint256 internal constant TICK_LIMIT_SPACING_BASIS_POINTS = 1000; /** * @notice Fixed point scale */ uint256 internal constant FIXED_POINT_SCALE = 1e18; /** * @notice Basis points scale */ uint256 internal constant BASIS_POINTS_SCALE = 10_000; /** * @notice Impaired price threshold (5%) */ uint256 internal constant IMPAIRED_PRICE_THRESHOLD = 0.05 * 1e18; /** * @notice Max ticks used count */ uint256 private constant MAX_TICKS_USED_COUNT = 32; /** * @notice Max redemption queue scan count */ uint256 private constant MAX_REDEMPTION_QUEUE_SCAN_COUNT = 150; /**************************************************************************/ /* Structures */ /**************************************************************************/ /** * @notice Node source * @param tick Tick * @param used Amount used * @param pending Amount pending */ struct NodeSource { uint128 tick; uint128 used; uint128 pending; } /** * @notice Fulfilled redemption * @param shares Shares redeemed * @param amount Amount redeemed */ struct FulfilledRedemption { uint128 shares; uint128 amount; } /** * @notice Redemption state * @param pending Pending shares * @param index Current index * @param fulfilled Fulfilled redemptions */ struct Redemptions { uint128 pending; uint128 index; mapping(uint128 => FulfilledRedemption) fulfilled; } /** * @notice Accrual state * @param accrued Accrued interest * @param rate Accrual rate * @param timestamp Last accrual timestamp */ struct Accrual { uint128 accrued; uint64 rate; uint64 timestamp; } /** * @notice Liquidity node * @param value Liquidity value * @param shares Liquidity shares outstanding * @param available Liquidity available * @param pending Liquidity pending (with interest) * @param prev Previous liquidity node * @param next Next liquidity node * @param redemption Redemption state * @param accrual Accrual state */ struct Node { uint128 value; uint128 shares; uint128 available; uint128 pending; uint128 prev; uint128 next; Redemptions redemptions; Accrual accrual; } /** * @notice Liquidity state * @param nodes Liquidity nodes */ struct Liquidity { mapping(uint256 => Node) nodes; } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * Get liquidity node at tick * @param liquidity Liquidity state * @param tick Tick * @return Liquidity node */ function liquidityNode(Liquidity storage liquidity, uint128 tick) public view returns (ILiquidity.NodeInfo memory) { Node storage node = liquidity.nodes[tick]; return ILiquidity.NodeInfo({ tick: tick, value: node.value, shares: node.shares, available: node.available, pending: node.pending, redemptions: node.redemptions.pending, prev: node.prev, next: node.next }); } /** * @notice Count liquidity nodes spanning [startTick, endTick] range, where * startTick is 0 or an instantiated tick * @param liquidity Liquidity state * @param startTick Start tick * @param endTick End tick * @return count Liquidity nodes count */ function liquidityNodesCount( Liquidity storage liquidity, uint128 startTick, uint128 endTick ) public view returns (uint256 count) { /* Validate start tick has active liquidity */ if (liquidity.nodes[startTick].next == 0) revert ILiquidity.InactiveLiquidity(); /* Count nodes */ uint256 t = startTick; while (t != type(uint128).max && t <= endTick) { t = liquidity.nodes[t].next; count++; } } /** * @notice Get liquidity nodes spanning [startTick, endTick] range, where * startTick is 0 or an instantiated tick * @param liquidity Liquidity state * @param startTick Start tick * @param endTick End tick * @return Liquidity nodes */ function liquidityNodes( Liquidity storage liquidity, uint128 startTick, uint128 endTick ) external view returns (ILiquidity.NodeInfo[] memory) { ILiquidity.NodeInfo[] memory nodes = new ILiquidity.NodeInfo[]( liquidityNodesCount(liquidity, startTick, endTick) ); /* Populate nodes */ uint256 i; uint128 t = startTick; while (t != type(uint128).max && t <= endTick) { nodes[i] = liquidityNode(liquidity, t); t = nodes[i++].next; } return nodes; } /** * @notice Get liquidity node with accrual info at tick * @param liquidity Liquidity state * @param tick Tick * @return Liquidity node, Accrual info */ function liquidityNodeWithAccrual( Liquidity storage liquidity, uint128 tick ) external view returns (ILiquidity.NodeInfo memory, ILiquidity.AccrualInfo memory) { Node storage node = liquidity.nodes[tick]; return ( ILiquidity.NodeInfo({ tick: tick, value: node.value, shares: node.shares, available: node.available, pending: node.pending, redemptions: node.redemptions.pending, prev: node.prev, next: node.next }), ILiquidity.AccrualInfo({ accrued: node.accrual.accrued, rate: node.accrual.rate, timestamp: node.accrual.timestamp }) ); } /** * @notice Get redemption available amount * @param liquidity Liquidity state * @param tick Tick * @param pending Redemption pending * @param index Redemption index * @param target Redemption target * @return redeemedShares Redeemed shares * @return redeemedAmount Redeemed amount * @return processedIndices Processed indices * @return processedShares Processed shares */ function redemptionAvailable( Liquidity storage liquidity, uint128 tick, uint128 pending, uint128 index, uint128 target ) internal view returns (uint128 redeemedShares, uint128 redeemedAmount, uint128 processedIndices, uint128 processedShares) { Node storage node = liquidity.nodes[tick]; uint256 stopIndex = index + MAX_REDEMPTION_QUEUE_SCAN_COUNT; for (; processedShares < target + pending && index < stopIndex; index++) { if (index == node.redemptions.index) { /* Reached pending unfulfilled redemption */ break; } /* Look up the next fulfilled redemption */ FulfilledRedemption storage redemption = node.redemptions.fulfilled[index]; /* Update processed count */ processedIndices += 1; processedShares += redemption.shares; if (processedShares <= target) { /* Have not reached the redemption queue position yet */ continue; } else { /* Compute number of shares to redeem in range of this * redemption batch */ uint128 shares = (((processedShares > target + pending) ? pending : (processedShares - target))) - redeemedShares; /* Compute price of shares in this redemption batch */ uint256 price = (redemption.amount * FIXED_POINT_SCALE) / redemption.shares; /* Accumulate redeemed shares and corresponding amount */ redeemedShares += shares; redeemedAmount += Math.mulDiv(shares, price, FIXED_POINT_SCALE).toUint128(); } } } /** * @notice Get deposit share price * @param liquidity Liquidity state * @param tick Tick * @return Deposit share price */ function depositSharePrice(Liquidity storage liquidity, uint128 tick) external view returns (uint256) { Node storage node = liquidity.nodes[tick]; /* Simulate accrual */ uint128 accrued = node.accrual.accrued + node.accrual.rate * uint128(block.timestamp - node.accrual.timestamp); /* Return deposit price */ return node.shares == 0 ? FIXED_POINT_SCALE : (Math.min(node.value + accrued, node.available + node.pending) * FIXED_POINT_SCALE) / node.shares; } /** * @notice Get redemption share price * @param liquidity Liquidity state * @param tick Tick * @return Redemption share price */ function redemptionSharePrice(Liquidity storage liquidity, uint128 tick) external view returns (uint256) { Node storage node = liquidity.nodes[tick]; /* Revert if node is empty */ if (node.value == 0 || node.shares == 0) revert ILiquidity.InactiveLiquidity(); /* Return redemption price */ return (node.value * FIXED_POINT_SCALE) / node.shares; } /**************************************************************************/ /* Internal Helpers */ /**************************************************************************/ /** * @dev Check if tick is reserved * @param tick Tick * @return True if reserved, otherwise false */ function _isReserved(uint128 tick) internal pure returns (bool) { return tick == 0 || tick == type(uint128).max; } /** * @dev Check if liquidity node is empty * @param node Liquidity node * @return True if empty, otherwise false */ function _isEmpty(Node storage node) internal view returns (bool) { return node.shares == 0 && node.pending == 0; } /** * @dev Check if liquidity node is active * @param node Liquidity node * @return True if active, otherwise false */ function _isActive(Node storage node) internal view returns (bool) { return node.prev != 0 || node.next != 0; } /** * @dev Check if liquidity node is impaired * @param node Liquidity node * @return True if impaired, otherwise false */ function _isImpaired(Node storage node) internal view returns (bool) { /* If there's shares, but insufficient value for a stable share price */ return node.shares != 0 && node.value * FIXED_POINT_SCALE < node.shares * IMPAIRED_PRICE_THRESHOLD; } /** * @notice Instantiate liquidity * @param liquidity Liquidity state * @param tick Tick */ function _instantiate(Liquidity storage liquidity, Node storage node, uint128 tick) internal { /* If node is active, do nothing */ if (_isActive(node)) return; /* If node is inactive and not empty, revert */ if (!_isEmpty(node)) revert ILiquidity.InactiveLiquidity(); /* Find prior node to new tick */ uint128 prevTick; Node storage prevNode = liquidity.nodes[prevTick]; while (prevNode.next < tick) { prevTick = prevNode.next; prevNode = liquidity.nodes[prevTick]; } /* Decode limits from previous tick, new tick, and next tick */ (uint256 prevLimit, , , ) = Tick.decode(prevTick); (uint256 newLimit, , , ) = Tick.decode(tick); (uint256 nextLimit, , , ) = Tick.decode(prevNode.next); /* Validate tick limit spacing */ if ( newLimit != prevLimit && newLimit < (prevLimit * (BASIS_POINTS_SCALE + TICK_LIMIT_SPACING_BASIS_POINTS)) / BASIS_POINTS_SCALE ) revert ILiquidity.InsufficientTickSpacing(); if ( newLimit != nextLimit && nextLimit < (newLimit * (BASIS_POINTS_SCALE + TICK_LIMIT_SPACING_BASIS_POINTS)) / BASIS_POINTS_SCALE ) revert ILiquidity.InsufficientTickSpacing(); /* Link new node */ node.prev = prevTick; node.next = prevNode.next; liquidity.nodes[prevNode.next].prev = tick; prevNode.next = tick; } /** * @dev Garbage collect an impaired or empty node, unlinking it from active * liquidity * @param liquidity Liquidity state * @param node Liquidity node */ function _garbageCollect(Liquidity storage liquidity, Node storage node) internal { /* If node is not impaired and not empty, or already inactive, do nothing */ if ((!_isImpaired(node) && !_isEmpty(node)) || !_isActive(node)) return; /* Make node inactive by unlinking it */ liquidity.nodes[node.prev].next = node.next; liquidity.nodes[node.next].prev = node.prev; node.next = 0; node.prev = 0; } /** * @notice Process redemptions from available liquidity * @param liquidity Liquidity state * @param node Liquidity node */ function _processRedemptions(Liquidity storage liquidity, Node storage node) internal { /* If there's no pending shares to redeem */ if (node.redemptions.pending == 0) return; /* Compute redemption price */ uint256 price = (node.value * FIXED_POINT_SCALE) / node.shares; if (price == 0) { /* If node has pending interest */ if (node.pending != 0) return; /* If node is insolvent, redeem all shares for zero amount */ uint128 shares = node.redemptions.pending; /* Record fulfilled redemption */ node.redemptions.fulfilled[node.redemptions.index++] = FulfilledRedemption({shares: shares, amount: 0}); /* Update node state */ node.shares -= shares; node.value = 0; node.available = 0; node.redemptions.pending = 0; return; } else { /* Node is solvent */ /* If there's no cash to redeem from */ if (node.available == 0) return; /* Redeem as many shares as possible and pending from available cash */ uint128 shares = uint128(Math.min((node.available * FIXED_POINT_SCALE) / price, node.redemptions.pending)); uint128 amount = Math.mulDiv(shares, price, FIXED_POINT_SCALE).toUint128(); /* If there's insufficient cash to redeem non-zero pending shares * at current price */ if (shares == 0) return; /* Record fulfilled redemption */ node.redemptions.fulfilled[node.redemptions.index++] = FulfilledRedemption({ shares: shares, amount: amount }); /* Update node state */ node.shares -= shares; node.value -= amount; node.available -= amount; node.redemptions.pending -= shares; /* Garbage collect node if it is now empty */ _garbageCollect(liquidity, node); return; } } /** * @notice Process accrued value from accrual rate and timestamp * @param node Liquidity node */ function _accrue(Node storage node) internal { node.accrual.accrued += node.accrual.rate * uint128(block.timestamp - node.accrual.timestamp); node.accrual.timestamp = uint64(block.timestamp); } /**************************************************************************/ /* Primary API */ /**************************************************************************/ /** * @notice Initialize liquidity state * @param liquidity Liquidity state */ function initialize(Liquidity storage liquidity) internal { /* Liquidity state defaults to zero, but need to make head and tail nodes */ liquidity.nodes[0].next = type(uint128).max; /* liquidity.nodes[type(uint128).max].prev = 0 by default */ } /** * @notice Deposit liquidity * @param liquidity Liquidity state * @param tick Tick * @param amount Amount * @return Number of shares */ function deposit(Liquidity storage liquidity, uint128 tick, uint128 amount) internal returns (uint128) { Node storage node = liquidity.nodes[tick]; /* If tick is reserved */ if (_isReserved(tick)) revert ILiquidity.InactiveLiquidity(); /* Instantiate node, if necessary */ _instantiate(liquidity, node, tick); /* Process accrual */ _accrue(node); /* Compute deposit price */ uint256 price = node.shares == 0 ? FIXED_POINT_SCALE : (Math.min(node.value + node.accrual.accrued, node.available + node.pending) * FIXED_POINT_SCALE) / node.shares; /* Compute shares */ uint128 shares = ((amount * FIXED_POINT_SCALE) / price).toUint128(); node.value += amount; node.shares += shares; node.available += amount; /* Process any pending redemptions from available cash */ _processRedemptions(liquidity, node); return shares; } /** * @notice Use liquidity from node * @param liquidity Liquidity state * @param tick Tick * @param used Used amount * @param pending Pending amount * @param duration Duration */ function use(Liquidity storage liquidity, uint128 tick, uint128 used, uint128 pending, uint64 duration) internal { Node storage node = liquidity.nodes[tick]; node.available -= used; node.pending += pending; /* Process accrual */ _accrue(node); /* Increment accrual rate */ uint256 rate = uint256(pending - used) / duration; node.accrual.rate += rate.toUint64(); } /** * @notice Restore liquidity and process pending redemptions * @param liquidity Liquidity state * @param tick Tick * @param used Used amount * @param pending Pending amount * @param restored Restored amount * @param duration Duration * @param elapsed Elapsed time since loan origination */ function restore( Liquidity storage liquidity, uint128 tick, uint128 used, uint128 pending, uint128 restored, uint64 duration, uint64 elapsed ) internal { Node storage node = liquidity.nodes[tick]; node.value = node.value - used + restored; node.available += restored; node.pending -= pending; /* Garbage collect node if it is now impaired */ _garbageCollect(liquidity, node); /* Process any pending redemptions */ _processRedemptions(liquidity, node); /* Process accrual */ _accrue(node); /* Decrement accrual rate and accrued */ uint256 rate = uint256(pending - used) / duration; node.accrual.rate -= rate.toUint64(); node.accrual.accrued -= uint128(rate * elapsed); } /** * @notice Redeem liquidity * @param liquidity Liquidity state * @param tick Tick * @param shares Shares * @return Redemption index, Redemption target */ function redeem(Liquidity storage liquidity, uint128 tick, uint128 shares) internal returns (uint128, uint128) { Node storage node = liquidity.nodes[tick]; /* Redemption from inactive liquidity nodes is allowed to facilitate * restoring garbage collected nodes */ /* Snapshot redemption target */ uint128 redemptionIndex = node.redemptions.index; uint128 redemptionTarget = node.redemptions.pending; /* Add shares to pending redemptions */ node.redemptions.pending += shares; /* Initialize redemption record to save gas in loan callbacks */ if (node.redemptions.fulfilled[redemptionIndex].shares != type(uint128).max) { node.redemptions.fulfilled[redemptionIndex] = FulfilledRedemption({shares: type(uint128).max, amount: 0}); } /* Process any pending redemptions from available cash */ _processRedemptions(liquidity, node); return (redemptionIndex, redemptionTarget); } /** * @notice Source liquidity from nodes * @param liquidity Liquidity state * @param amount Amount * @param ticks Ticks to source from * @param multiplier Multiplier for amount * @param durationIndex Duration index for amount * @return Sourced liquidity nodes, count of nodes */ function source( Liquidity storage liquidity, uint256 amount, uint128[] calldata ticks, uint256 multiplier, uint256 durationIndex ) internal view returns (NodeSource[] memory, uint16) { NodeSource[] memory sources = new NodeSource[](ticks.length); uint256 prevTick; uint256 taken; uint256 count; for (; count < ticks.length && taken != amount; count++) { uint128 tick = ticks[count]; /* Validate tick and decode limit */ uint256 limit = Tick.validate(tick, prevTick, durationIndex); /* Look up liquidity node */ Node storage node = liquidity.nodes[tick]; /* Consume as much as possible up to the tick limit, amount available, and amount remaining */ uint128 take = uint128(Math.min(Math.min(limit * multiplier - taken, node.available), amount - taken)); /* Record the liquidity allocation in our sources list */ sources[count] = NodeSource({tick: tick, used: take, pending: 0}); taken += take; prevTick = tick; } /* If unable to source required liquidity amount from provided ticks */ if (taken < amount) revert ILiquidity.InsufficientLiquidity(); /* If count exceeds max number of ticks */ if (count > MAX_TICKS_USED_COUNT) revert ILiquidity.InsufficientLiquidity(); return (sources, count.toUint16()); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; /** * @title LoanReceipt * @author MetaStreet Labs */ library LoanReceipt { /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid receipt encoding */ error InvalidReceiptEncoding(); /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Loan receipt version */ uint8 internal constant LOAN_RECEIPT_VERSION = 2; /** * @notice Loan receipt header size in bytes * @dev Header excludes borrow options byte array */ uint256 internal constant LOAN_RECEIPT_HEADER_SIZE = 187; /** * @notice Loan receipt node receipt size in bytes */ uint256 internal constant LOAN_RECEIPT_NODE_RECEIPT_SIZE = 48; /**************************************************************************/ /* Structures */ /**************************************************************************/ /** * @notice LoanReceiptV2 * @param version Version (2) * @param principal Principal amount in currency tokens * @param repayment Repayment amount in currency tokens * @param adminFee Admin fee amount in currency tokens * @param borrower Borrower * @param maturity Loan maturity timestamp * @param duration Loan duration * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param collateralWrapperContextLen Collateral wrapper context length * @param collateralWrapperContext Collateral wrapper context data * @param nodeReceipts Node receipts */ struct LoanReceiptV2 { uint8 version; uint256 principal; uint256 repayment; uint256 adminFee; address borrower; uint64 maturity; uint64 duration; address collateralToken; uint256 collateralTokenId; uint16 collateralWrapperContextLen; bytes collateralWrapperContext; NodeReceipt[] nodeReceipts; } /** * @notice Node receipt * @param tick Tick * @param used Used amount * @param pending Pending amount */ struct NodeReceipt { uint128 tick; uint128 used; uint128 pending; } /**************************************************************************/ /* Tightly packed format */ /**************************************************************************/ /* Header (187 bytes) 1 uint8 version 0:1 32 uint256 principal 1:33 32 uint256 repayment 33:65 32 uint256 adminFee 65:97 20 address borrower 97:117 8 uint64 maturity 117:125 8 uint64 duration 125:133 20 address collateralToken 133:153 32 uint256 collateralTokenId 153:185 2 uint16 collateralWrapperContextLen 185:187 Collateral Wrapper Context Data (M bytes) 187:--- Node Receipts (48 * N bytes) N NodeReceipts[] nodeReceipts 16 uint128 tick 16 uint128 used 16 uint128 pending */ /**************************************************************************/ /* API */ /**************************************************************************/ /** * @dev Compute loan receipt hash * @param encodedReceipt Encoded loan receipt * @return Loan Receipt hash */ function hash(bytes memory encodedReceipt) internal view returns (bytes32) { /* Take hash of chain ID (32 bytes) concatenated with encoded loan receipt */ return keccak256(abi.encodePacked(block.chainid, encodedReceipt)); } /** * @dev Encode a loan receipt into bytes * @param receipt Loan Receipt * @return Encoded loan receipt */ function encode(LoanReceiptV2 memory receipt) internal pure returns (bytes memory) { /* Encode header */ bytes memory header = abi.encodePacked( receipt.version, receipt.principal, receipt.repayment, receipt.adminFee, receipt.borrower, receipt.maturity, receipt.duration, receipt.collateralToken, receipt.collateralTokenId, receipt.collateralWrapperContextLen, receipt.collateralWrapperContext ); /* Encode node receipts */ bytes memory nodeReceipts; for (uint256 i; i < receipt.nodeReceipts.length; i++) { nodeReceipts = abi.encodePacked( nodeReceipts, receipt.nodeReceipts[i].tick, receipt.nodeReceipts[i].used, receipt.nodeReceipts[i].pending ); } return abi.encodePacked(header, nodeReceipts); } /** * @dev Decode a loan receipt from bytes * @param encodedReceipt Encoded loan Receipt * @return Decoded loan receipt */ function decode(bytes calldata encodedReceipt) internal pure returns (LoanReceiptV2 memory) { /* Validate encoded receipt length */ if (encodedReceipt.length < LOAN_RECEIPT_HEADER_SIZE) revert InvalidReceiptEncoding(); uint256 collateralWrapperContextLen = uint16(bytes2(encodedReceipt[185:187])); /* Validate length with collateral wrapper context */ if (encodedReceipt.length < LOAN_RECEIPT_HEADER_SIZE + collateralWrapperContextLen) revert InvalidReceiptEncoding(); /* Validate length with node receipts */ if ( (encodedReceipt.length - LOAN_RECEIPT_HEADER_SIZE - collateralWrapperContextLen) % LOAN_RECEIPT_NODE_RECEIPT_SIZE != 0 ) revert InvalidReceiptEncoding(); /* Validate encoded receipt version */ if (uint8(encodedReceipt[0]) != LOAN_RECEIPT_VERSION) revert InvalidReceiptEncoding(); LoanReceiptV2 memory receipt; /* Decode header */ receipt.version = uint8(encodedReceipt[0]); receipt.principal = uint256(bytes32(encodedReceipt[1:33])); receipt.repayment = uint256(bytes32(encodedReceipt[33:65])); receipt.adminFee = uint256(bytes32(encodedReceipt[65:97])); receipt.borrower = address(uint160(bytes20(encodedReceipt[97:117]))); receipt.maturity = uint64(bytes8(encodedReceipt[117:125])); receipt.duration = uint64(bytes8(encodedReceipt[125:133])); receipt.collateralToken = address(uint160(bytes20(encodedReceipt[133:153]))); receipt.collateralTokenId = uint256(bytes32(encodedReceipt[153:185])); receipt.collateralWrapperContextLen = uint16(collateralWrapperContextLen); receipt.collateralWrapperContext = encodedReceipt[187:187 + collateralWrapperContextLen]; /* Decode node receipts */ uint256 numNodeReceipts = (encodedReceipt.length - LOAN_RECEIPT_HEADER_SIZE - collateralWrapperContextLen) / LOAN_RECEIPT_NODE_RECEIPT_SIZE; receipt.nodeReceipts = new NodeReceipt[](numNodeReceipts); uint256 offset = LOAN_RECEIPT_HEADER_SIZE + collateralWrapperContextLen; for (uint256 i; i < numNodeReceipts; i++) { receipt.nodeReceipts[i].tick = uint128(bytes16(encodedReceipt[offset:offset + 16])); receipt.nodeReceipts[i].used = uint128(bytes16(encodedReceipt[offset + 16:offset + 32])); receipt.nodeReceipts[i].pending = uint128(bytes16(encodedReceipt[offset + 32:offset + 48])); offset += LOAN_RECEIPT_NODE_RECEIPT_SIZE; } return receipt; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; import "@openzeppelin/contracts/utils/Multicall.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol"; import "@openzeppelin/contracts/utils/math/SafeCast.sol"; import "./filters/CollateralFilter.sol"; import "./rates/InterestRateModel.sol"; import "./tokenization/DepositToken.sol"; import "./LoanReceipt.sol"; import "./LiquidityLogic.sol"; import "./DepositLogic.sol"; import "./BorrowLogic.sol"; import "./interfaces/IPool.sol"; import "./interfaces/ILiquidity.sol"; import "./interfaces/ICollateralWrapper.sol"; import "./interfaces/ICollateralLiquidator.sol"; import "./interfaces/ICollateralLiquidationReceiver.sol"; /** * @title Pool * @author MetaStreet Labs */ abstract contract Pool is ERC165, ReentrancyGuard, Multicall, CollateralFilter, InterestRateModel, DepositToken, IPool, ILiquidity, ICollateralLiquidationReceiver { using SafeCast for uint256; using SafeERC20 for IERC20; using LiquidityLogic for LiquidityLogic.Liquidity; /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Tick spacing basis points */ uint256 public constant TICK_LIMIT_SPACING_BASIS_POINTS = LiquidityLogic.TICK_LIMIT_SPACING_BASIS_POINTS; /**************************************************************************/ /* Structures */ /**************************************************************************/ /** * @notice Redemption * @param pending Redemption shares pending * @param index Redemption queue index * @param target Redemption queue target */ struct Redemption { uint128 pending; uint128 index; uint128 target; } /** * @notice Deposit * @param shares Shares * @param redemptionId Next Redemption ID * @param redemptions Mapping of redemption ID to redemption */ struct Deposit { uint128 shares; uint128 redemptionId; mapping(uint128 => Redemption) redemptions; } /** * @notice Delegate * @param version Delegate version * @param to Delegate address */ struct Delegate { DelegateVersion version; address to; } /** * @custom:storage-location erc7201:pool.delegateStorage */ struct DelegateStorage { /* Mapping of collateralToken to token ID to Delegate */ mapping(address => mapping(uint256 => Delegate)) delegates; } /** * @notice Loan status */ enum LoanStatus { Uninitialized, Active, Repaid, Liquidated, CollateralLiquidated } /** * @notice Borrow function options */ enum BorrowOptions { None, CollateralWrapperContext, CollateralFilterContext, DelegateCashV1, DelegateCashV2 } /** * @notice Delegate version */ enum DelegateVersion { None, DelegateCashV1, DelegateCashV2 } /**************************************************************************/ /* Immutable State */ /**************************************************************************/ /** * @notice Collateral wrappers (max 3) */ address internal immutable _collateralWrapper1; address internal immutable _collateralWrapper2; address internal immutable _collateralWrapper3; /** * @notice Collateral liquidator */ ICollateralLiquidator internal immutable _collateralLiquidator; /** * @notice Delegate registry v1 contract */ address internal immutable _delegateRegistryV1; /** * @notice Delegate registry v2 contract */ address internal immutable _delegateRegistryV2; /** * @notice Delegate cash storage slot * @dev keccak256(abi.encode(uint256(keccak256("erc7201:pool.delegateStorage")) - 1)) & ~bytes32(uint256(0xff)); */ bytes32 internal constant DELEGATE_STORAGE_LOCATION = 0xf0e5094ebd597f2042580340ce53d1b15e5b64e0d8be717ecde51dd37c619300; /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Pool Storage * @param currencyToken Currency token contract * @param adminFeeRate Admin free rate in basis points * @param durations Durations * @param rates Rates * @param admin Admin * @param adminFeeBalance Admin fee balance * @param liquidity Liquidity * @param deposits Mapping of account to tick to deposit * @param loans Mapping of loan receipt hash to loan status */ struct PoolStorage { IERC20 currencyToken; uint32 adminFeeRate; uint64[] durations; uint64[] rates; address admin; uint256 adminFeeBalance; LiquidityLogic.Liquidity liquidity; mapping(address => mapping(uint128 => Deposit)) deposits; mapping(bytes32 => LoanStatus) loans; } /** * @notice Pool state */ PoolStorage internal _storage; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice Pool constructor * @param collateralLiquidator_ Collateral liquidator * @param delegateRegistryV1_ Delegate registry v1 contract * @param delegateRegistryV2_ Delegate registry v2 contract * @param collateralWrappers_ Collateral wrappers */ constructor( address collateralLiquidator_, address delegateRegistryV1_, address delegateRegistryV2_, address[] memory collateralWrappers_ ) { if (collateralWrappers_.length > 3) revert InvalidParameters(); _collateralLiquidator = ICollateralLiquidator(collateralLiquidator_); _delegateRegistryV1 = delegateRegistryV1_; _delegateRegistryV2 = delegateRegistryV2_; _collateralWrapper1 = (collateralWrappers_.length > 0) ? collateralWrappers_[0] : address(0); _collateralWrapper2 = (collateralWrappers_.length > 1) ? collateralWrappers_[1] : address(0); _collateralWrapper3 = (collateralWrappers_.length > 2) ? collateralWrappers_[2] : address(0); } /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice Pool initializer * @dev Fee-on-transfer currency tokens are not supported * @param currencyToken_ Currency token contract * @param durations_ Duration tiers * @param rates_ Interest rate tiers */ function _initialize(address currencyToken_, uint64[] memory durations_, uint64[] memory rates_) internal { if (IERC20Metadata(currencyToken_).decimals() != 18) revert InvalidParameters(); _storage.currencyToken = IERC20(currencyToken_); _storage.admin = msg.sender; /* Assign durations */ if (durations_.length > Tick.MAX_NUM_DURATIONS) revert InvalidParameters(); for (uint256 i; i < durations_.length; i++) { /* Check duration is monotonic */ if (i != 0 && durations_[i] >= durations_[i - 1]) revert InvalidParameters(); _storage.durations.push(durations_[i]); } /* Assign rates */ if (rates_.length > Tick.MAX_NUM_RATES) revert InvalidParameters(); for (uint256 i; i < rates_.length; i++) { /* Check rate is monotonic */ if (i != 0 && rates_[i] <= rates_[i - 1]) revert InvalidParameters(); _storage.rates.push(rates_[i]); } /* Initialize liquidity */ _storage.liquidity.initialize(); } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @notice Get implementation name * @return Implementation name */ function IMPLEMENTATION_NAME() external pure virtual returns (string memory); /** * @notice Get implementation version * @return Implementation version */ function IMPLEMENTATION_VERSION() external pure returns (string memory) { return "2.7.1"; } /** * @inheritdoc IPool */ function currencyToken() external view returns (address) { return address(_storage.currencyToken); } /** * @inheritdoc IPool */ function durations() external view returns (uint64[] memory) { return _storage.durations; } /** * @inheritdoc IPool */ function rates() external view returns (uint64[] memory) { return _storage.rates; } /** * @inheritdoc IPool */ function admin() external view returns (address) { return _storage.admin; } /** * @inheritdoc IPool */ function adminFeeRate() external view returns (uint32) { return _storage.adminFeeRate; } /** * @inheritdoc IPool */ function adminFeeBalance() external view returns (uint256) { return _storage.adminFeeBalance; } /** * @inheritdoc IPool */ function collateralWrappers() external view returns (address[] memory) { address[] memory collateralWrappers_ = new address[](3); collateralWrappers_[0] = _collateralWrapper1; collateralWrappers_[1] = _collateralWrapper2; collateralWrappers_[2] = _collateralWrapper3; return collateralWrappers_; } /** * @inheritdoc IPool */ function collateralLiquidator() external view returns (address) { return address(_collateralLiquidator); } /** * @inheritdoc IPool */ function delegationRegistry() external view returns (address) { return address(_delegateRegistryV1); } /** * @inheritdoc IPool */ function delegationRegistryV2() external view returns (address) { return address(_delegateRegistryV2); } /** * @notice Get deposit * @param account Account * @param tick Tick * @return shares Shares * @return redemptionId Redemption ID */ function deposits(address account, uint128 tick) external view returns (uint128 shares, uint128 redemptionId) { shares = _storage.deposits[account][tick].shares; redemptionId = _storage.deposits[account][tick].redemptionId; } /** * @notice Get redemption * @param account Account * @param tick Tick * @param redemptionId Redemption ID * @return Redemption */ function redemptions( address account, uint128 tick, uint128 redemptionId ) external view returns (Redemption memory) { return _storage.deposits[account][tick].redemptions[redemptionId]; } /** * @notice Get loan status * @param receiptHash Loan receipt hash * @return Loan status */ function loans(bytes32 receiptHash) external view returns (LoanStatus) { return _storage.loans[receiptHash]; } /** * @inheritdoc ILiquidity */ function liquidityNodes(uint128 startTick, uint128 endTick) external view returns (NodeInfo[] memory) { return _storage.liquidity.liquidityNodes(startTick, endTick); } /** * @inheritdoc ILiquidity */ function liquidityNode(uint128 tick) external view returns (NodeInfo memory) { return _storage.liquidity.liquidityNode(tick); } /** * @inheritdoc ILiquidity */ function liquidityNodeWithAccrual(uint128 tick) external view returns (NodeInfo memory, AccrualInfo memory) { return _storage.liquidity.liquidityNodeWithAccrual(tick); } /** * @inheritdoc ILiquidity */ function depositSharePrice(uint128 tick) external view returns (uint256) { return _storage.liquidity.depositSharePrice(tick); } /** * @inheritdoc ILiquidity */ function redemptionSharePrice(uint128 tick) external view returns (uint256) { return _storage.liquidity.redemptionSharePrice(tick); } /**************************************************************************/ /* Loan Receipt External Helpers */ /**************************************************************************/ /** * @notice Decode loan receipt * @param loanReceipt Loan receipt * @return Decoded loan receipt */ function decodeLoanReceipt(bytes calldata loanReceipt) external pure returns (LoanReceipt.LoanReceiptV2 memory) { return BorrowLogic._decodeLoanReceipt(loanReceipt); } /**************************************************************************/ /* Helper Functions */ /**************************************************************************/ /** * @notice Helper function that returns underlying collateral in (address, * uint256[], uint256) shape * @param collateralToken Collateral token, either underlying token or collateral wrapper * @param collateralTokenId Collateral token ID * @param collateralWrapperContext Collateral wrapper context * @return token Underlying collateral token * @return tokenIds Underlying collateral token IDs (unique) * @return tokenCount Underlying total token count */ function _getUnderlyingCollateral( address collateralToken, uint256 collateralTokenId, bytes memory collateralWrapperContext ) internal view returns (address token, uint256[] memory tokenIds, uint256 tokenCount) { /* Enumerate if collateral token is a collateral wrapper */ if ( collateralToken == _collateralWrapper1 || collateralToken == _collateralWrapper2 || collateralToken == _collateralWrapper3 ) { (token, tokenIds) = ICollateralWrapper(collateralToken).enumerate( collateralTokenId, collateralWrapperContext ); tokenCount = ICollateralWrapper(collateralToken).count(collateralTokenId, collateralWrapperContext); return (token, tokenIds, tokenCount); } /* If single asset, convert to length one token ID array */ token = collateralToken; tokenIds = new uint256[](1); tokenIds[0] = collateralTokenId; tokenCount = 1; } /** * @notice Get reference to ERC-7201 delegate storage * @return $ Reference to delegate storage */ function _getDelegateStorage() private pure returns (DelegateStorage storage $) { assembly { $.slot := DELEGATE_STORAGE_LOCATION } } /** * @dev Helper function to quote a loan * @param principal Principal amount in currency tokens * @param duration Duration in seconds * @param collateralToken Collateral token address * @param collateralTokenId Collateral token ID * @param ticks Liquidity node ticks * @param collateralWrapperContext Collateral wrapper context * @param collateralFilterContext Collateral filter context * @param isRefinance True if called by refinance() * @return Repayment amount in currency tokens, admin fee in currency * tokens, liquidity nodes, liquidity node count */ function _quote( uint256 principal, uint64 duration, address collateralToken, uint256 collateralTokenId, uint128[] calldata ticks, bytes memory collateralWrapperContext, bytes calldata collateralFilterContext, bool isRefinance ) internal view returns (uint256, uint256, LiquidityLogic.NodeSource[] memory, uint16) { /* Get underlying collateral */ ( address underlyingCollateralToken, uint256[] memory underlyingCollateralTokenIds, uint256 underlyingCollateralTokenCount ) = _getUnderlyingCollateral(collateralToken, collateralTokenId, collateralWrapperContext); /* Verify collateral is supported */ if (!isRefinance) { for (uint256 i; i < underlyingCollateralTokenIds.length; i++) { if ( !_collateralSupported( underlyingCollateralToken, underlyingCollateralTokenIds[i], i, collateralFilterContext ) ) revert UnsupportedCollateral(i); } } /* Cache durations */ uint64[] memory durations_ = _storage.durations; /* Validate duration */ if (duration > durations_[0]) revert UnsupportedLoanDuration(); /* Lookup duration index */ uint256 durationIndex = durations_.length - 1; for (; durationIndex > 0; durationIndex--) { if (duration <= durations_[durationIndex]) break; } /* Source liquidity nodes */ (LiquidityLogic.NodeSource[] memory nodes, uint16 count) = _storage.liquidity.source( principal, ticks, underlyingCollateralTokenCount, durationIndex ); /* Price interest for liquidity nodes */ (uint256 repayment, uint256 adminFee) = _price( principal, duration, nodes, count, _storage.rates, _storage.adminFeeRate ); return (repayment, adminFee, nodes, count); } /**************************************************************************/ /* Lend API */ /**************************************************************************/ /** * @inheritdoc IPool */ function quote( uint256 principal, uint64 duration, address collateralToken, uint256 collateralTokenId, uint128[] calldata ticks, bytes calldata options ) external view returns (uint256) { /* Quote repayment */ (uint256 repayment, , , ) = _quote( principal, duration, collateralToken, collateralTokenId, ticks, BorrowLogic._getOptionsData(options, BorrowOptions.CollateralWrapperContext), BorrowLogic._getOptionsData(options, BorrowOptions.CollateralFilterContext), false ); return repayment; } /** * @inheritdoc IPool */ function borrow( uint256 principal, uint64 duration, address collateralToken, uint256 collateralTokenId, uint256 maxRepayment, uint128[] calldata ticks, bytes calldata options ) external nonReentrant returns (uint256) { /* Quote repayment, admin fee, and liquidity nodes */ (uint256 repayment, uint256 adminFee, LiquidityLogic.NodeSource[] memory nodes, uint16 count) = _quote( principal, duration, collateralToken, collateralTokenId, ticks, BorrowLogic._getOptionsData(options, BorrowOptions.CollateralWrapperContext), BorrowLogic._getOptionsData(options, BorrowOptions.CollateralFilterContext), false ); /* Handle borrow accounting */ (bytes memory encodedLoanReceipt, bytes32 loanReceiptHash) = BorrowLogic._borrow( _storage, principal, duration, collateralToken, collateralTokenId, repayment, maxRepayment, adminFee, nodes, count, BorrowLogic._getOptionsData(options, BorrowOptions.CollateralWrapperContext) ); /* Handle delegate.cash option */ BorrowLogic._optionDelegateCash( _getDelegateStorage(), collateralToken, collateralTokenId, _delegateRegistryV1, _delegateRegistryV2, options ); /* Transfer collateral from borrower to pool */ IERC721(collateralToken).transferFrom(msg.sender, address(this), collateralTokenId); /* Transfer principal from pool to borrower */ _storage.currencyToken.safeTransfer(msg.sender, principal); /* Emit LoanOriginated */ emit LoanOriginated(loanReceiptHash, encodedLoanReceipt); return repayment; } /** * @inheritdoc IPool */ function repay(bytes calldata encodedLoanReceipt) external nonReentrant returns (uint256) { /* Handle repay accounting */ (uint256 repayment, LoanReceipt.LoanReceiptV2 memory loanReceipt, bytes32 loanReceiptHash) = BorrowLogic._repay( _storage, encodedLoanReceipt ); /* Revoke delegates */ BorrowLogic._revokeDelegates( _getDelegateStorage(), loanReceipt.collateralToken, loanReceipt.collateralTokenId, _delegateRegistryV1, _delegateRegistryV2 ); /* Transfer repayment from borrower to pool */ _storage.currencyToken.safeTransferFrom(loanReceipt.borrower, address(this), repayment); /* Transfer collateral from pool to borrower */ IERC721(loanReceipt.collateralToken).transferFrom( address(this), loanReceipt.borrower, loanReceipt.collateralTokenId ); /* Emit Loan Repaid */ emit LoanRepaid(loanReceiptHash, repayment); return repayment; } /** * @inheritdoc IPool */ function refinance( bytes calldata encodedLoanReceipt, uint256 principal, uint64 duration, uint256 maxRepayment, uint128[] calldata ticks ) external nonReentrant returns (uint256) { /* Handle repay accounting */ (uint256 repayment, LoanReceipt.LoanReceiptV2 memory loanReceipt, bytes32 loanReceiptHash) = BorrowLogic._repay( _storage, encodedLoanReceipt ); /* Quote new repayment, admin fee, and liquidity nodes */ (uint256 newRepayment, uint256 adminFee, LiquidityLogic.NodeSource[] memory nodes, uint16 count) = _quote( principal, duration, loanReceipt.collateralToken, loanReceipt.collateralTokenId, ticks, loanReceipt.collateralWrapperContext, encodedLoanReceipt[0:0], true ); /* Handle borrow accounting */ (bytes memory newEncodedLoanReceipt, bytes32 newLoanReceiptHash) = BorrowLogic._borrow( _storage, principal, duration, loanReceipt.collateralToken, loanReceipt.collateralTokenId, newRepayment, maxRepayment, adminFee, nodes, count, loanReceipt.collateralWrapperContext ); /* Determine transfer direction */ if (principal < repayment) { /* Transfer prorated repayment less principal from borrower to pool */ _storage.currencyToken.safeTransferFrom(loanReceipt.borrower, address(this), repayment - principal); } else { /* Transfer principal less prorated repayment from pool to borrower */ _storage.currencyToken.safeTransfer(msg.sender, principal - repayment); } /* Emit Loan Repaid */ emit LoanRepaid(loanReceiptHash, repayment); /* Emit LoanOriginated */ emit LoanOriginated(newLoanReceiptHash, newEncodedLoanReceipt); return newRepayment; } /** * @inheritdoc IPool */ function liquidate(bytes calldata encodedLoanReceipt) external nonReentrant { /* Handle liquidate accounting */ (LoanReceipt.LoanReceiptV2 memory loanReceipt, bytes32 loanReceiptHash) = BorrowLogic._liquidate( _storage, encodedLoanReceipt ); /* Revoke delegates */ BorrowLogic._revokeDelegates( _getDelegateStorage(), loanReceipt.collateralToken, loanReceipt.collateralTokenId, _delegateRegistryV1, _delegateRegistryV2 ); /* Approve collateral for transfer to _collateralLiquidator */ IERC721(loanReceipt.collateralToken).approve(address(_collateralLiquidator), loanReceipt.collateralTokenId); /* Start liquidation with collateral liquidator */ _collateralLiquidator.liquidate( address(_storage.currencyToken), loanReceipt.collateralToken, loanReceipt.collateralTokenId, loanReceipt.collateralWrapperContext, encodedLoanReceipt ); /* Emit Loan Liquidated */ emit LoanLiquidated(loanReceiptHash); } /**************************************************************************/ /* Callbacks */ /**************************************************************************/ /** * @inheritdoc ICollateralLiquidationReceiver */ function onCollateralLiquidated(bytes calldata encodedLoanReceipt, uint256 proceeds) external nonReentrant { /* Validate caller is collateral liquidator */ if (msg.sender != address(_collateralLiquidator)) revert InvalidCaller(); /* Handle collateral liquidation accounting */ (uint256 borrowerSurplus, LoanReceipt.LoanReceiptV2 memory loanReceipt, bytes32 loanReceiptHash) = BorrowLogic ._onCollateralLiquidated(_storage, encodedLoanReceipt, proceeds); /* Transfer surplus to borrower */ if (borrowerSurplus != 0) IERC20(_storage.currencyToken).safeTransfer(loanReceipt.borrower, borrowerSurplus); /* Emit Collateral Liquidated */ emit CollateralLiquidated(loanReceiptHash, proceeds, borrowerSurplus); } /**************************************************************************/ /* Deposit API */ /**************************************************************************/ /** * @inheritdoc IPool */ function deposit(uint128 tick, uint256 amount, uint256 minShares) external nonReentrant returns (uint256) { /* Handle deposit accounting and compute shares */ uint128 shares = DepositLogic._deposit(_storage, tick, amount.toUint128(), minShares.toUint128()); /* Call token hook */ _onExternalTransfer(address(0), msg.sender, tick, shares); /* Transfer deposit amount */ _storage.currencyToken.safeTransferFrom(msg.sender, address(this), amount); /* Emit Deposited */ emit Deposited(msg.sender, tick, amount, shares); return shares; } /** * @inheritdoc IPool */ function redeem(uint128 tick, uint256 shares) external nonReentrant returns (uint128) { /* Handle redeem accounting */ uint128 redemptionId = DepositLogic._redeem(_storage, tick, shares.toUint128()); /* Call token hook */ _onExternalTransfer(msg.sender, address(0), tick, shares); /* Emit Redeemed event */ emit Redeemed(msg.sender, tick, redemptionId, shares); return redemptionId; } /** * @inheritdoc IPool */ function redemptionAvailable( address account, uint128 tick, uint128 redemptionId ) external view returns (uint256 shares, uint256 amount, uint256 sharesAhead) { /* Handle redemption available accounting */ return DepositLogic._redemptionAvailable(_storage, account, tick, redemptionId); } /** * @inheritdoc IPool */ function withdraw(uint128 tick, uint128 redemptionId) external nonReentrant returns (uint256, uint256) { /* Handle withdraw accounting and compute both shares and amount */ (uint128 shares, uint128 amount) = DepositLogic._withdraw(_storage, tick, redemptionId); /* Transfer withdrawal amount */ if (amount != 0) _storage.currencyToken.safeTransfer(msg.sender, amount); /* Emit Withdrawn */ emit Withdrawn(msg.sender, tick, redemptionId, shares, amount); return (shares, amount); } /** * @inheritdoc IPool */ function rebalance( uint128 srcTick, uint128 dstTick, uint128 redemptionId, uint256 minShares ) external nonReentrant returns (uint256, uint256, uint256) { /* Handle withdraw accounting and compute both shares and amount */ (uint128 oldShares, uint128 amount) = DepositLogic._withdraw(_storage, srcTick, redemptionId); /* Handle deposit accounting and compute new shares */ uint128 newShares = DepositLogic._deposit(_storage, dstTick, amount, minShares.toUint128()); /* Call token hook */ _onExternalTransfer(address(0), msg.sender, dstTick, newShares); /* Emit Withdrawn */ emit Withdrawn(msg.sender, srcTick, redemptionId, oldShares, amount); /* Emit Deposited */ emit Deposited(msg.sender, dstTick, amount, newShares); return (oldShares, newShares, amount); } /** * @notice Transfer shares between accounts by operator * * @dev Only callable by deposit token contract * * @param from From * @param to To * @param tick Tick * @param shares Shares */ function transfer(address from, address to, uint128 tick, uint256 shares) external nonReentrant { /* Validate caller is deposit token created by Pool */ if (msg.sender != depositToken(tick)) revert InvalidCaller(); /* Handle transfer accounting */ DepositLogic._transfer(_storage, from, to, tick, shares.toUint128()); /* Emit Transferred */ emit Transferred(from, to, tick, shares); } /** * @notice Tokenize a tick * * @param tick Tick * @return Deposit token address */ function tokenize(uint128 tick) external returns (address) { /* Validate tick */ Tick.validate(tick, 0, 0, _storage.durations.length - 1, 0, _storage.rates.length - 1); return _tokenize(tick); } /**************************************************************************/ /* Admin Fees API */ /**************************************************************************/ /** * @notice Set the admin fee rate * * Emits a {AdminFeeRateUpdated} event. * * @param rate Rate is the admin fee in basis points */ function setAdminFeeRate(uint32 rate) external { if (msg.sender != _storage.admin) revert InvalidCaller(); if (rate >= LiquidityLogic.BASIS_POINTS_SCALE) revert InvalidParameters(); _storage.adminFeeRate = rate; emit AdminFeeRateUpdated(rate); } /** * @notice Withdraw admin fees * * Emits a {AdminFeesWithdrawn} event. * * @param recipient Recipient account * @param amount Amount to withdraw */ function withdrawAdminFees(address recipient, uint256 amount) external nonReentrant { if (msg.sender != _storage.admin) revert InvalidCaller(); if (recipient == address(0) || amount > _storage.adminFeeBalance) revert InvalidParameters(); /* Update admin fees balance */ _storage.adminFeeBalance -= amount; /* Transfer cash from Pool to recipient */ _storage.currencyToken.safeTransfer(recipient, amount); emit AdminFeesWithdrawn(recipient, amount); } /******************************************************/ /* ERC165 interface */ /******************************************************/ /** * @inheritdoc IERC165 */ function supportsInterface(bytes4 interfaceId) public view override returns (bool) { return interfaceId == type(ICollateralLiquidationReceiver).interfaceId || super.supportsInterface(interfaceId); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol"; import "@openzeppelin/contracts/proxy/Clones.sol"; import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol"; import "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol"; import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol"; import "./interfaces/IPoolFactory.sol"; /** * @title PoolFactory * @author MetaStreet Labs */ contract PoolFactory is Ownable, ERC1967Upgrade, IPoolFactory { using EnumerableSet for EnumerableSet.AddressSet; /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Implementation version */ string public constant IMPLEMENTATION_VERSION = "1.2"; /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Initialized boolean */ bool private _initialized; /** * @notice Set of deployed pools */ EnumerableSet.AddressSet private _pools; /** * @notice Set of allowed pool implementations */ EnumerableSet.AddressSet private _allowedImplementations; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice PoolFactory constructor */ constructor() { /* Disable initialization of implementation contract */ _initialized = true; /* Disable owner of implementation contract */ renounceOwnership(); } /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice PoolFactory initializator */ function initialize() external { require(!_initialized, "Already initialized"); _initialized = true; _transferOwnership(msg.sender); } /**************************************************************************/ /* Primary API */ /**************************************************************************/ /* * @inheritdoc IPoolFactory */ function create(address poolImplementation, bytes calldata params) external returns (address) { /* Validate pool implementation */ if (!_allowedImplementations.contains(poolImplementation)) revert UnsupportedImplementation(); /* Create pool instance */ address poolInstance = Clones.clone(poolImplementation); Address.functionCall(poolInstance, abi.encodeWithSignature("initialize(bytes)", params)); /* Add pool to registry */ _pools.add(poolInstance); /* Emit Pool Created */ emit PoolCreated(poolInstance, poolImplementation); return poolInstance; } /* * @inheritdoc IPoolFactory */ function createProxied(address poolBeacon, bytes calldata params) external returns (address) { /* Validate pool implementation */ if (!_allowedImplementations.contains(poolBeacon)) revert UnsupportedImplementation(); /* Create pool instance */ address poolInstance = address( new BeaconProxy(poolBeacon, abi.encodeWithSignature("initialize(bytes)", params)) ); /* Add pool to registry */ _pools.add(poolInstance); /* Emit Pool Created */ emit PoolCreated(poolInstance, poolBeacon); return poolInstance; } /** * @inheritdoc IPoolFactory */ function isPool(address pool) public view returns (bool) { return _pools.contains(pool); } /** * @inheritdoc IPoolFactory */ function getPools() external view returns (address[] memory) { return _pools.values(); } /** * @inheritdoc IPoolFactory */ function getPoolCount() external view returns (uint256) { return _pools.length(); } /** * @inheritdoc IPoolFactory */ function getPoolAt(uint256 index) external view returns (address) { return _pools.at(index); } /** * @inheritdoc IPoolFactory */ function getPoolImplementations() external view returns (address[] memory) { return _allowedImplementations.values(); } /**************************************************************************/ /* Admin API */ /**************************************************************************/ /** * @notice Set pool admin fee rate * @param pool Pool address * @param rate Rate is the admin fee in basis points */ function setAdminFeeRate(address pool, uint32 rate) external onlyOwner { /* Validate pool */ if (!isPool(pool)) revert InvalidPool(); Address.functionCall(pool, abi.encodeWithSignature("setAdminFeeRate(uint32)", rate)); } /** * @notice Add pool implementation to allowlist * @param poolImplementation Pool implementation */ function addPoolImplementation(address poolImplementation) external onlyOwner { if (_allowedImplementations.add(poolImplementation)) { emit PoolImplementationAdded(poolImplementation); } } /** * @notice Remove pool implementation from allowlist * @param poolImplementation Pool implementation */ function removePoolImplementation(address poolImplementation) external onlyOwner { if (_allowedImplementations.remove(poolImplementation)) { emit PoolImplementationRemoved(poolImplementation); } } /** * @notice Get Proxy Implementation * @return Implementation address */ function getImplementation() external view returns (address) { return _getImplementation(); } /** * @notice Upgrade Proxy * @param newImplementation New implementation contract * @param data Optional calldata */ function upgradeToAndCall(address newImplementation, bytes calldata data) external onlyOwner { _upgradeToAndCall(newImplementation, data, false); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../LiquidityLogic.sol"; /** * @title Interest Rate Model API * @author MetaStreet Labs */ abstract contract InterestRateModel { /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid parameters */ error InvalidInterestRateModelParameters(); /**************************************************************************/ /* API */ /**************************************************************************/ /** * @notice Get interest rate model name * @return Interest rate model name */ function INTEREST_RATE_MODEL_NAME() external view virtual returns (string memory); /** * @notice Get interest rate model version * @return Interest rate model version */ function INTEREST_RATE_MODEL_VERSION() external view virtual returns (string memory); /** * @notice Price interest for liquidity * @param principal Principal * @param duration Duration * @param nodes Liquidity nodes * @param count Liquidity node count * @param rates Interest rates * @param adminFeeRate Admin fee rate * @return repayment Repayment * @return adminFee Admin fee */ function _price( uint256 principal, uint64 duration, LiquidityLogic.NodeSource[] memory nodes, uint16 count, uint64[] memory rates, uint32 adminFeeRate ) internal view virtual returns (uint256 repayment, uint256 adminFee); }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/utils/math/Math.sol"; import "@openzeppelin/contracts/utils/math/SafeCast.sol"; import "./InterestRateModel.sol"; import "../Tick.sol"; /** * @title Weighted Interest Rate Model * @author MetaStreet Labs */ contract WeightedInterestRateModel is InterestRateModel { using SafeCast for uint256; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice WeightedInterestRateModel constructor */ constructor() {} /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc InterestRateModel */ function INTEREST_RATE_MODEL_NAME() external pure override returns (string memory) { return "WeightedInterestRateModel"; } /** * @inheritdoc InterestRateModel */ function INTEREST_RATE_MODEL_VERSION() external pure override returns (string memory) { return "2.0"; } /** * @inheritdoc InterestRateModel */ function _price( uint256 principal, uint64 duration, LiquidityLogic.NodeSource[] memory nodes, uint16 count, uint64[] memory rates, uint32 adminFeeRate ) internal pure override returns (uint256, uint256) { /* First pass to compute repayment and weights */ uint256[] memory weights = new uint256[](count); uint256 repayment; uint256 normalization; for (uint256 i; i < count; i++) { /* Compute tick repayment */ (, , uint256 rateIndex, ) = Tick.decode(nodes[i].tick); uint256 pending = nodes[i].used + Math.mulDiv(nodes[i].used, rates[rateIndex] * duration, LiquidityLogic.FIXED_POINT_SCALE); /* Update cumulative repayment */ repayment += pending; /* Compute tick weight */ weights[i] = Math.mulDiv(repayment, pending, principal); /* Accumulate weight for normalization */ normalization += weights[i]; } /* Compute interest and admin fee */ uint256 interest = repayment - principal; uint256 adminFee = (interest * adminFeeRate) / LiquidityLogic.BASIS_POINTS_SCALE; /* Deduct admin fee from interest */ interest -= adminFee; /* Second pass to assign weighted interest to ticks */ uint256 interestRemaining = interest; for (uint256 i; i < count; i++) { /* Compute weighted interest to tick */ uint256 weightedInterest = Math.mulDiv(interest, weights[i], normalization); /* Assign node pending amount */ nodes[i].pending = nodes[i].used + weightedInterest.toUint128(); /* Track remaining interest */ interestRemaining -= weightedInterest; } /* Drop off remaining interest dust at lowest node */ if (interestRemaining != 0) nodes[0].pending += interestRemaining.toUint128(); return (repayment, adminFee); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/access/AccessControl.sol"; import "../interfaces/ICollateralLiquidationReceiver.sol"; import "../interfaces/ICollateralLiquidator.sol"; import "../interfaces/IPool.sol"; /** * @title External Collateral Liquidator (trusted) * @author MetaStreet Labs */ contract ExternalCollateralLiquidator is AccessControl, ICollateralLiquidator, ReentrancyGuard { using SafeERC20 for IERC20; /**************************************************************************/ /* Access Control Roles */ /**************************************************************************/ /** * @notice Collateral liquidator role */ bytes32 public constant COLLATERAL_LIQUIDATOR_ROLE = keccak256("COLLATERAL_LIQUIDATOR"); /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Implementation version */ string public constant IMPLEMENTATION_VERSION = "1.0"; /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid token */ error InvalidToken(); /** * @notice Invalid caller */ error InvalidCaller(); /** * @notice Invalid liquidation */ error InvalidLiquidation(); /** * @notice Invalid collateral state */ error InvalidCollateralState(); /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when collateral is received * @param collateralHash Collateral hash * @param source Source that provided collateral * @param collateralToken Collateral token contract * @param collateralTokenId Collateral token ID */ event CollateralReceived( bytes32 indexed collateralHash, address indexed source, address collateralToken, uint256 collateralTokenId ); /** * @notice Emitted when collateral is withdrawn * @param collateralHash Collateral hash * @param source Source that provided collateral * @param collateralToken Collateral token contract * @param collateralTokenId Collateral token ID */ event CollateralWithdrawn( bytes32 indexed collateralHash, address indexed source, address collateralToken, uint256 collateralTokenId ); /** * @notice Emitted when collateral is liquidated * @param collateralHash Collateral hash * @param collateralToken Collateral token contract * @param collateralTokenId Collateral token ID * @param proceeds Proceeds in currency tokens */ event CollateralLiquidated( bytes32 indexed collateralHash, address collateralToken, uint256 collateralTokenId, uint256 proceeds ); /**************************************************************************/ /* Enums */ /**************************************************************************/ /** * @notice Collateral Status */ enum CollateralStatus { Absent, Present, Withdrawn } /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Initialized boolean */ bool private _initialized; /** * @dev Collateral tracker */ mapping(bytes32 => CollateralStatus) private _collateralTracker; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice ExternalCollateralLiquidator constructor */ constructor() { /* Disable initialization of implementation contract */ _initialized = true; } /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice Initializer */ function initialize() external { require(!_initialized, "Already initialized"); _initialized = true; _grantRole(DEFAULT_ADMIN_ROLE, msg.sender); } /**************************************************************************/ /* Helper Functions */ /**************************************************************************/ /** * @notice Helper function to compute collateral hash * @param source Source that provided collateral * @param collateralToken Collateral token * @param collateralTokenId Collateral token ID * @param currencyToken Currency token * @param collateralWrapperContext Collateral wrapper context * @param liquidationContext Liquidation callback context */ function _collateralHash( address source, address collateralToken, uint256 collateralTokenId, address currencyToken, bytes calldata collateralWrapperContext, bytes calldata liquidationContext ) internal view returns (bytes32) { return keccak256( abi.encodePacked( block.chainid, source, collateralToken, collateralTokenId, collateralWrapperContext, currencyToken, liquidationContext ) ); } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * Get collateral status * @param collateralHash Collateral hash * @return Collateral tracker */ function collateralStatus(bytes32 collateralHash) external view returns (CollateralStatus) { return _collateralTracker[collateralHash]; } /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc ICollateralLiquidator */ function name() external pure returns (string memory) { return "ExternalCollateralLiquidator"; } /** * @inheritdoc ICollateralLiquidator */ function liquidate( address currencyToken, address collateralToken, uint256 collateralTokenId, bytes calldata collateralWrapperContext, bytes calldata liquidationContext ) external nonReentrant { /* Check collateralToken and currencyToken is not zero address */ if (collateralToken == address(0) || currencyToken == address(0)) revert InvalidToken(); /* Compute liquidation hash */ bytes32 collateralHash = _collateralHash( msg.sender, collateralToken, collateralTokenId, currencyToken, collateralWrapperContext, liquidationContext ); /* Validate collateral is not already present */ if (_collateralTracker[collateralHash] != CollateralStatus.Absent) revert InvalidLiquidation(); /* Transfer collateral token from source to this contract */ IERC721(collateralToken).transferFrom(msg.sender, address(this), collateralTokenId); /* Update collateral tracker */ _collateralTracker[collateralHash] = CollateralStatus.Present; /* Emit CollateralReceived */ emit CollateralReceived(collateralHash, msg.sender, collateralToken, collateralTokenId); } /** * @notice Withdraw collateral * * Emits a {CollateralWithdrawn} event. * * @param source Source that provided collateral * @param currencyToken Currency token * @param collateralToken Collateral token, either underlying token or collateral wrapper * @param collateralTokenId Collateral token ID * @param collateralWrapperContext Collateral wrapper context * @param liquidationContext Liquidation callback context */ function withdrawCollateral( address source, address currencyToken, address collateralToken, uint256 collateralTokenId, bytes calldata collateralWrapperContext, bytes calldata liquidationContext ) external onlyRole(COLLATERAL_LIQUIDATOR_ROLE) { /* Compute collateral hash */ bytes32 collateralHash = _collateralHash( source, collateralToken, collateralTokenId, currencyToken, collateralWrapperContext, liquidationContext ); /* Validate collateral is present */ if (_collateralTracker[collateralHash] != CollateralStatus.Present) revert InvalidCollateralState(); /* Transfer collateral to caller */ IERC721(collateralToken).safeTransferFrom(address(this), msg.sender, collateralTokenId); /* Update collateral tracker */ _collateralTracker[collateralHash] = CollateralStatus.Withdrawn; emit CollateralWithdrawn(collateralHash, source, collateralToken, collateralTokenId); } /** * @notice Liquidate collateral * * Emits a {CollateralLiquidated} event. * * @param source Source that provided collateral * @param collateralToken Collateral token from liquidate parameter earlier * @param collateralTokenId Collateral token ID from liquidate parameter earlier * @param collateralWrapperContext Collateral wrapper context * @param liquidationContext Liquidation context */ function liquidateCollateral( address source, address currencyToken, address collateralToken, uint256 collateralTokenId, bytes calldata collateralWrapperContext, bytes calldata liquidationContext, uint256 proceeds ) external onlyRole(COLLATERAL_LIQUIDATOR_ROLE) { /* Compute collateral hash */ bytes32 collateralHash = _collateralHash( source, collateralToken, collateralTokenId, currencyToken, collateralWrapperContext, liquidationContext ); /* Validate collateral is present */ if (_collateralTracker[collateralHash] != CollateralStatus.Withdrawn) revert InvalidCollateralState(); /* Transfer proceeds from caller to this contract */ IERC20(currencyToken).safeTransferFrom(msg.sender, address(this), proceeds); /* Transfer collateral to caller */ IERC20(currencyToken).transfer(source, proceeds); /* If transfer is successful and source is a contract, try collateral liquidation callback */ if (Address.isContract(source)) try ICollateralLiquidationReceiver(source).onCollateralLiquidated(liquidationContext, proceeds) {} catch {} /* Emit CollateralLiquidated() */ emit CollateralLiquidated(collateralHash, collateralToken, collateralTokenId, proceeds); /* Delete underlying collateral */ delete _collateralTracker[collateralHash]; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "../../filters/CollectionCollateralFilter.sol"; /** * @title Test Contract Wrapper for CollectionCollateralFilter * @author MetaStreet Labs */ contract TestCollectionCollateralFilter is CollectionCollateralFilter { /**************************************************************************/ /* Constructor */ /**************************************************************************/ constructor(address[] memory tokens) { _initialize(tokens); } /**************************************************************************/ /* Wrapper for Primary API */ /**************************************************************************/ /** * @dev External wrapper function for _collateralSupported */ function collateralSupported( address token, uint256 tokenId, uint256 index, bytes calldata context ) external view returns (bool) { return _collateralSupported(token, tokenId, index, context); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "../../filters/MerkleCollectionCollateralFilter.sol"; /** * @title Test Contract Wrapper for MerkleCollectionCollateralFilter * @author MetaStreet Labs */ contract TestMerkleCollectionCollateralFilter is MerkleCollectionCollateralFilter { /**************************************************************************/ /* Constructor */ /**************************************************************************/ constructor(address token, bytes32 root, uint32 nodeCount, string memory metadataURI) { _initialize(token, root, nodeCount, metadataURI); } /**************************************************************************/ /* Wrapper for Primary API */ /**************************************************************************/ /** * @dev External wrapper function for _collateralSupported */ function collateralSupported( address token, uint256 tokenId, uint256 index, bytes calldata context ) external view returns (bool) { return _collateralSupported(token, tokenId, index, context); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "../../filters/RangedCollectionCollateralFilter.sol"; /** * @title Test Contract Wrapper for RangedCollectionCollateralFilter * @author MetaStreet Labs */ contract TestRangedCollectionCollateralFilter is RangedCollectionCollateralFilter { /**************************************************************************/ /* Constructor */ /**************************************************************************/ constructor(address token, uint256 startTokenId, uint256 endTokenId) { _initialize(token, startTokenId, endTokenId); } /**************************************************************************/ /* Wrapper for Primary API */ /**************************************************************************/ /** * @dev External wrapper function for _collateralSupported */ function collateralSupported( address token, uint256 tokenId, uint256 index, bytes calldata context ) external view returns (bool) { return _collateralSupported(token, tokenId, index, context); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "../../filters/SetCollectionCollateralFilter.sol"; /** * @title Test Contract Wrapper for SetCollectionCollateralFilter * @author MetaStreet Labs */ contract TestSetCollectionCollateralFilter is SetCollectionCollateralFilter { /**************************************************************************/ /* Constructor */ /**************************************************************************/ constructor(address token, uint256[] memory tokenIds) { _initialize(token, tokenIds); } /**************************************************************************/ /* Wrapper for Primary API */ /**************************************************************************/ /** * @dev External wrapper function for _collateralSupported */ function collateralSupported( address token, uint256 tokenId, uint256 index, bytes calldata context ) external view returns (bool) { return _collateralSupported(token, tokenId, index, context); } }
// SPDX-License-Identifier: CC0-1.0 pragma solidity ^0.8.20; import {IDelegateRegistryV2} from "../../../../integrations/DelegateCash/IDelegateRegistryV2.sol"; /** * @title Library for calculating the hashes and storage locations used in the delegate registry * * The encoding for the 5 types of delegate registry hashes should be as follows: * * ALL: keccak256(abi.encodePacked(rights, from, to)) * CONTRACT: keccak256(abi.encodePacked(rights, from, to, contract_)) * ERC721: keccak256(abi.encodePacked(rights, from, to, contract_, tokenId)) * ERC20: keccak256(abi.encodePacked(rights, from, to, contract_)) * ERC1155: keccak256(abi.encodePacked(rights, from, to, contract_, tokenId)) * * To avoid collisions between the hashes with respect to type, the hash is shifted left by one byte * and the last byte is then encoded with a unique number for the delegation type * */ library RegistryHashes { /// @dev Used to delete everything but the last byte of a 32 byte word with and(word, EXTRACT_LAST_BYTE) uint256 internal constant EXTRACT_LAST_BYTE = 0xff; /// @dev Constants for the delegate registry delegation type enumeration uint256 internal constant ALL_TYPE = 1; uint256 internal constant CONTRACT_TYPE = 2; uint256 internal constant ERC721_TYPE = 3; uint256 internal constant ERC20_TYPE = 4; uint256 internal constant ERC1155_TYPE = 5; /// @dev Constant for the location of the delegations array in the delegate registry, defined to be zero uint256 internal constant DELEGATION_SLOT = 0; /** * @notice Helper function to decode last byte of a delegation hash into its delegation type enum * @param inputHash The bytehash to decode the type from * @return decodedType The delegation type */ function decodeType(bytes32 inputHash) internal pure returns (IDelegateRegistryV2.DelegationType decodedType) { assembly { decodedType := and(inputHash, EXTRACT_LAST_BYTE) } } /** * @notice Helper function that computes the storage location of a particular delegation array * @dev Storage keys further down the array can be obtained by adding computedLocation with the element position * @dev Follows the solidity storage location encoding for a mapping(bytes32 => fixedArray) at the position of the delegationSlot * @param inputHash The bytehash to decode the type from * @return computedLocation is the storage key of the delegation array at position 0 */ function location(bytes32 inputHash) internal pure returns (bytes32 computedLocation) { assembly ("memory-safe") { // This block only allocates memory in the scratch space mstore(0, inputHash) mstore(32, DELEGATION_SLOT) computedLocation := keccak256(0, 64) // Run keccak256 over bytes in scratch space to obtain the storage key } } /** * @notice Helper function to compute delegation hash for `DelegationType.ALL` * @dev Equivalent to `keccak256(abi.encodePacked(rights, from, to))` then left-shift by 1 byte and write the delegation type to the cleaned last byte * @dev Will not revert if `from` or `to` are > uint160, any input larger than uint160 for `from` and `to` will be cleaned to its lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @return hash The delegation parameters encoded with ALL_TYPE */ function allHash(address from, bytes32 rights, address to) internal pure returns (bytes32 hash) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer let ptr := mload(64) // Load the free memory pointer // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) hash := or(shl(8, keccak256(ptr, 72)), ALL_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte } } /** * @notice Helper function to compute delegation location for `DelegationType.ALL` * @dev Equivalent to `location(allHash(rights, from, to))` * @dev Will not revert if `from` or `to` are > uint160, any input larger than uint160 for `from` and `to` will be cleaned to its lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @return computedLocation The storage location of the all delegation with those parameters in the delegations mapping */ function allLocation(address from, bytes32 rights, address to) internal pure returns (bytes32 computedLocation) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer and in the scratch space let ptr := mload(64) // Load the free memory pointer // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) mstore(0, or(shl(8, keccak256(ptr, 72)), ALL_TYPE)) // Computes `allHash`, then stores the result in scratch space mstore(32, DELEGATION_SLOT) computedLocation := keccak256(0, 64) // Runs keccak over the scratch space to obtain the storage key } } /** * @notice Helper function to compute delegation hash for `DelegationType.CONTRACT` * @dev Equivalent to keccak256(abi.encodePacked(rights, from, to, contract_)) left-shifted by 1 then last byte overwritten with CONTRACT_TYPE * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @param contract_ The address of the contract specified by the delegation * @return hash The delegation parameters encoded with CONTRACT_TYPE */ function contractHash( address from, bytes32 rights, address to, address contract_ ) internal pure returns (bytes32 hash) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer let ptr := mload(64) // Load the free memory pointer // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 60), contract_) mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) hash := or(shl(8, keccak256(ptr, 92)), CONTRACT_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte } } /** * @notice Helper function to compute delegation location for `DelegationType.CONTRACT` * @dev Equivalent to `location(contractHash(rights, from, to, contract_))` * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @param contract_ The address of the contract specified by the delegation * @return computedLocation The storage location of the contract delegation with those parameters in the delegations mapping */ function contractLocation( address from, bytes32 rights, address to, address contract_ ) internal pure returns (bytes32 computedLocation) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer and in the scratch space let ptr := mload(64) // Load free memory pointer // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 60), contract_) mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) mstore(0, or(shl(8, keccak256(ptr, 92)), CONTRACT_TYPE)) // Computes `contractHash`, then stores the result in scratch space mstore(32, DELEGATION_SLOT) computedLocation := keccak256(0, 64) // Runs keccak over the scratch space to obtain the storage key } } /** * @notice Helper function to compute delegation hash for `DelegationType.ERC721` * @dev Equivalent to `keccak256(abi.encodePacked(rights, from, to, contract_, tokenId)) left-shifted by 1 then last byte overwritten with ERC721_TYPE * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @param tokenId The id of the token specified by the delegation * @param contract_ The address of the contract specified by the delegation * @return hash The delegation parameters encoded with ERC721_TYPE */ function erc721Hash( address from, bytes32 rights, address to, uint256 tokenId, address contract_ ) internal pure returns (bytes32 hash) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer let ptr := mload(64) // Cache the free memory pointer. // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 92), tokenId) mstore(add(ptr, 60), contract_) mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) hash := or(shl(8, keccak256(ptr, 124)), ERC721_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte } } /** * @notice Helper function to compute delegation location for `DelegationType.ERC721` * @dev Equivalent to `location(ERC721Hash(rights, from, to, contract_, tokenId))` * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @param tokenId The id of the ERC721 token * @param contract_ The address of the ERC721 token contract * @return computedLocation The storage location of the ERC721 delegation with those parameters in the delegations mapping */ function erc721Location( address from, bytes32 rights, address to, uint256 tokenId, address contract_ ) internal pure returns (bytes32 computedLocation) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer and in the scratch space let ptr := mload(64) // Cache the free memory pointer. // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 92), tokenId) mstore(add(ptr, 60), contract_) mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) mstore(0, or(shl(8, keccak256(ptr, 124)), ERC721_TYPE)) // Computes erc721Hash, then stores the result in scratch space mstore(32, DELEGATION_SLOT) computedLocation := keccak256(0, 64) // Runs keccak256 over the scratch space to obtain the storage key } } /** * @notice Helper function to compute delegation hash for `DelegationType.ERC20` * @dev Equivalent to `keccak256(abi.encodePacked(rights, from, to, contract_))` with the last byte overwritten with ERC20_TYPE * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @param contract_ The address of the ERC20 token contract * @return hash The parameters encoded with ERC20_TYPE */ function erc20Hash( address from, bytes32 rights, address to, address contract_ ) internal pure returns (bytes32 hash) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer let ptr := mload(64) // Load free memory pointer // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 60), contract_) mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) hash := or(shl(8, keccak256(ptr, 92)), ERC20_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte } } /** * @notice Helper function to compute delegation location for `DelegationType.ERC20` * @dev Equivalent to `location(ERC20Hash(rights, from, to, contract_))` * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @param contract_ The address of the ERC20 token contract * @return computedLocation The storage location of the ERC20 delegation with those parameters in the delegations mapping */ function erc20Location( address from, bytes32 rights, address to, address contract_ ) internal pure returns (bytes32 computedLocation) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer and in the scratch space let ptr := mload(64) // Loads the free memory pointer // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 60), contract_) mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) mstore(0, or(shl(8, keccak256(ptr, 92)), ERC20_TYPE)) // Computes erc20Hash, then stores the result in scratch space mstore(32, DELEGATION_SLOT) computedLocation := keccak256(0, 64) // Runs keccak over the scratch space to obtain the storage key } } /** * @notice Helper function to compute delegation hash for `DelegationType.ERC1155` * @dev Equivalent to keccak256(abi.encodePacked(rights, from, to, contract_, tokenId)) left-shifted with the last byte overwritten with ERC1155_TYPE * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @param tokenId The id of the ERC1155 token * @param contract_ The address of the ERC1155 token contract * @return hash The parameters encoded with ERC1155_TYPE */ function erc1155Hash( address from, bytes32 rights, address to, uint256 tokenId, address contract_ ) internal pure returns (bytes32 hash) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer let ptr := mload(64) // Load the free memory pointer. // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 92), tokenId) mstore(add(ptr, 60), contract_) mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) hash := or(shl(8, keccak256(ptr, 124)), ERC1155_TYPE) // Keccak-hashes the packed encoding, left-shifts by one byte, then writes type to the lowest-order byte } } /** * @notice Helper function to compute delegation location for `DelegationType.ERC1155` * @dev Equivalent to `location(ERC1155Hash(rights, from, to, contract_, tokenId))` * @dev Will not revert if `from`, `to` or `contract_` are > uint160, these inputs will be cleaned to their lower 20 bytes * @param from The address making the delegation * @param rights The rights specified by the delegation * @param to The address receiving the delegation * @param tokenId The id of the ERC1155 token * @param contract_ The address of the ERC1155 token contract * @return computedLocation The storage location of the ERC1155 delegation with those parameters in the delegations mapping */ function erc1155Location( address from, bytes32 rights, address to, uint256 tokenId, address contract_ ) internal pure returns (bytes32 computedLocation) { assembly ("memory-safe") { // This block only allocates memory after the free memory pointer and in the scratch space let ptr := mload(64) // Cache the free memory pointer. // Lay out the variables from last to first, agnostic to upper 96 bits of address words. mstore(add(ptr, 92), tokenId) mstore(add(ptr, 60), contract_) mstore(add(ptr, 40), to) mstore(add(ptr, 20), from) mstore(ptr, rights) mstore(0, or(shl(8, keccak256(ptr, 124)), ERC1155_TYPE)) // Computes erc1155Hash, then stores the result in scratch space mstore(32, DELEGATION_SLOT) computedLocation := keccak256(0, 64) // Runs keccak over the scratch space to obtain the storage key } } }
// SPDX-License-Identifier: CC0-1.0 pragma solidity ^0.8.20; library RegistryOps { /// @dev `x > y ? x : y`. function max(uint256 x, uint256 y) internal pure returns (uint256 z) { assembly { // `gt(y, x)` will evaluate to 1 if `y > x`, else 0. // // If `y > x`: // `x ^ ((x ^ y) * 1) = x ^ (x ^ y) = (x ^ x) ^ y = 0 ^ y = y`. // otherwise: // `x ^ ((x ^ y) * 0) = x ^ 0 = x`. z := xor(x, mul(xor(x, y), gt(y, x))) } } /// @dev `x & y`. function and(bool x, bool y) internal pure returns (bool z) { assembly { z := and(iszero(iszero(x)), iszero(iszero(y))) // Compiler cleans dirty booleans on the stack to 1, so do the same here } } /// @dev `x | y`. function or(bool x, bool y) internal pure returns (bool z) { assembly { z := or(iszero(iszero(x)), iszero(iszero(y))) // Compiler cleans dirty booleans on the stack to 1, so do the same here } } }
// SPDX-License-Identifier: CC0-1.0 pragma solidity ^0.8.20; library RegistryStorage { /// @dev Standardizes `from` storage flags to prevent double-writes in the delegation in/outbox if the same delegation is revoked and rewritten address internal constant DELEGATION_EMPTY = address(0); address internal constant DELEGATION_REVOKED = address(1); /// @dev Standardizes storage positions of delegation data uint256 internal constant POSITIONS_FIRST_PACKED = 0; // | 4 bytes empty | first 8 bytes of contract address | 20 bytes of from address | uint256 internal constant POSITIONS_SECOND_PACKED = 1; // | last 12 bytes of contract address | 20 bytes of to address | uint256 internal constant POSITIONS_RIGHTS = 2; uint256 internal constant POSITIONS_TOKEN_ID = 3; uint256 internal constant POSITIONS_AMOUNT = 4; /// @dev Used to clean address types of dirty bits with `and(address, CLEAN_ADDRESS)` uint256 internal constant CLEAN_ADDRESS = 0x00ffffffffffffffffffffffffffffffffffffffff; /// @dev Used to clean everything but the first 8 bytes of an address uint256 internal constant CLEAN_FIRST8_BYTES_ADDRESS = 0xffffffffffffffff << 96; /// @dev Used to clean everything but the first 8 bytes of an address in the packed position uint256 internal constant CLEAN_PACKED8_BYTES_ADDRESS = 0xffffffffffffffff << 160; /** * @notice Helper function that packs from, to, and contract_ address to into the two slot configuration * @param from The address making the delegation * @param to The address receiving the delegation * @param contract_ The contract address associated with the delegation (optional) * @return firstPacked The firstPacked storage configured with the parameters * @return secondPacked The secondPacked storage configured with the parameters * @dev Will not revert if `from`, `to`, and `contract_` are > uint160, any inputs with dirty bits outside the last 20 bytes will be cleaned */ function packAddresses( address from, address to, address contract_ ) internal pure returns (bytes32 firstPacked, bytes32 secondPacked) { assembly { firstPacked := or(shl(64, and(contract_, CLEAN_FIRST8_BYTES_ADDRESS)), and(from, CLEAN_ADDRESS)) secondPacked := or(shl(160, contract_), and(to, CLEAN_ADDRESS)) } } /** * @notice Helper function that unpacks from, to, and contract_ address inside the firstPacked secondPacked storage configuration * @param firstPacked The firstPacked storage to be decoded * @param secondPacked The secondPacked storage to be decoded * @return from The address making the delegation * @return to The address receiving the delegation * @return contract_ The contract address associated with the delegation * @dev Will not revert if `from`, `to`, and `contract_` are > uint160, any inputs with dirty bits outside the last 20 bytes will be cleaned */ function unpackAddresses( bytes32 firstPacked, bytes32 secondPacked ) internal pure returns (address from, address to, address contract_) { assembly { from := and(firstPacked, CLEAN_ADDRESS) to := and(secondPacked, CLEAN_ADDRESS) contract_ := or(shr(64, and(firstPacked, CLEAN_PACKED8_BYTES_ADDRESS)), shr(160, secondPacked)) } } /** * @notice Helper function that can unpack the from or to address from their respective packed slots in the registry * @param packedSlot The slot containing the from or to address * @return unpacked The `from` or `to` address * @dev Will not work if you want to obtain the contract address, use unpackAddresses */ function unpackAddress(bytes32 packedSlot) internal pure returns (address unpacked) { assembly { unpacked := and(packedSlot, CLEAN_ADDRESS) } } }
// SPDX-License-Identifier: CC0-1.0 pragma solidity ^0.8.19; import "../../../integrations/DelegateCash/IDelegateRegistryV1.sol"; import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol"; import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; /** * @title Test DelegationRegistry * * @dev Subset of full contract */ contract TestDelegateRegistryV1 is IDelegateRegistryV1, ERC165 { using EnumerableSet for EnumerableSet.AddressSet; using EnumerableSet for EnumerableSet.Bytes32Set; /// @notice The global mapping and single source of truth for delegations /// @dev vault -> vaultVersion -> delegationHash mapping(address => mapping(uint256 => EnumerableSet.Bytes32Set)) internal delegations; /// @notice A mapping of wallets to versions (for cheap revocation) mapping(address => uint256) internal vaultVersion; /// @notice A mapping of wallets to delegates to versions (for cheap revocation) mapping(address => mapping(address => uint256)) internal delegateVersion; /// @notice A secondary mapping to return onchain enumerability of delegations that a given address can perform /// @dev delegate -> delegationHashes mapping(address => EnumerableSet.Bytes32Set) internal delegationHashes; /// @notice A secondary mapping used to return delegation information about a delegation /// @dev delegationHash -> DelegateInfo mapping(bytes32 => IDelegateRegistryV1.DelegationInfo) internal delegationInfo; /** * @inheritdoc ERC165 */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165) returns (bool) { return interfaceId == type(IDelegateRegistryV1).interfaceId || super.supportsInterface(interfaceId); } /** * ----------- WRITE ----------- */ /** * @inheritdoc IDelegateRegistryV1 */ function delegateForToken(address delegate, address contract_, uint256 tokenId, bool value) external override { bytes32 delegationHash = _computeTokenDelegationHash(msg.sender, delegate, contract_, tokenId); _setDelegationValues( delegate, delegationHash, value, IDelegateRegistryV1.DelegationType.TOKEN, msg.sender, contract_, tokenId ); emit IDelegateRegistryV1.DelegateForToken(msg.sender, delegate, contract_, tokenId, value); } /** * @dev Helper function to set all delegation values and enumeration sets */ function _setDelegationValues( address delegate, bytes32 delegateHash, bool value, IDelegateRegistryV1.DelegationType type_, address vault, address contract_, uint256 tokenId ) internal { if (value) { delegations[vault][vaultVersion[vault]].add(delegateHash); delegationHashes[delegate].add(delegateHash); delegationInfo[delegateHash] = DelegationInfo({ vault: vault, delegate: delegate, type_: type_, contract_: contract_, tokenId: tokenId }); } else { delegations[vault][vaultVersion[vault]].remove(delegateHash); delegationHashes[delegate].remove(delegateHash); delete delegationInfo[delegateHash]; } } /** * @dev Helper function to compute delegation hash for wallet delegation */ function _computeAllDelegationHash(address vault, address delegate) internal view returns (bytes32) { uint256 vaultVersion_ = vaultVersion[vault]; uint256 delegateVersion_ = delegateVersion[vault][delegate]; return keccak256(abi.encode(delegate, vault, vaultVersion_, delegateVersion_)); } /** * @dev Helper function to compute delegation hash for contract delegation */ function _computeContractDelegationHash( address vault, address delegate, address contract_ ) internal view returns (bytes32) { uint256 vaultVersion_ = vaultVersion[vault]; uint256 delegateVersion_ = delegateVersion[vault][delegate]; return keccak256(abi.encode(delegate, vault, contract_, vaultVersion_, delegateVersion_)); } /** * @dev Helper function to compute delegation hash for token delegation */ function _computeTokenDelegationHash( address vault, address delegate, address contract_, uint256 tokenId ) internal view returns (bytes32) { uint256 vaultVersion_ = vaultVersion[vault]; uint256 delegateVersion_ = delegateVersion[vault][delegate]; return keccak256(abi.encode(delegate, vault, contract_, tokenId, vaultVersion_, delegateVersion_)); } /** * ----------- READ ----------- */ /** * @inheritdoc IDelegateRegistryV1 */ function getDelegatesForToken( address vault, address contract_, uint256 tokenId ) external view override returns (address[] memory delegates) { return _getDelegatesForLevel(vault, IDelegateRegistryV1.DelegationType.TOKEN, contract_, tokenId); } function _getDelegatesForLevel( address vault, IDelegateRegistryV1.DelegationType delegationType, address contract_, uint256 tokenId ) internal view returns (address[] memory delegates) { EnumerableSet.Bytes32Set storage delegationHashes_ = delegations[vault][vaultVersion[vault]]; uint256 potentialDelegatesLength = delegationHashes_.length(); uint256 delegatesCount = 0; delegates = new address[](potentialDelegatesLength); for (uint256 i = 0; i < potentialDelegatesLength; ) { bytes32 delegationHash = delegationHashes_.at(i); DelegationInfo storage delegationInfo_ = delegationInfo[delegationHash]; if (delegationInfo_.type_ == delegationType) { if (delegationType == IDelegateRegistryV1.DelegationType.ALL) { // check delegate version by validating the hash if (delegationHash == _computeAllDelegationHash(vault, delegationInfo_.delegate)) { delegates[delegatesCount++] = delegationInfo_.delegate; } } else if (delegationType == IDelegateRegistryV1.DelegationType.CONTRACT) { if (delegationInfo_.contract_ == contract_) { // check delegate version by validating the hash if ( delegationHash == _computeContractDelegationHash(vault, delegationInfo_.delegate, contract_) ) { delegates[delegatesCount++] = delegationInfo_.delegate; } } } else if (delegationType == IDelegateRegistryV1.DelegationType.TOKEN) { if (delegationInfo_.contract_ == contract_ && delegationInfo_.tokenId == tokenId) { // check delegate version by validating the hash if ( delegationHash == _computeTokenDelegationHash(vault, delegationInfo_.delegate, contract_, tokenId) ) { delegates[delegatesCount++] = delegationInfo_.delegate; } } } } unchecked { ++i; } } if (potentialDelegatesLength > delegatesCount) { assembly { let decrease := sub(potentialDelegatesLength, delegatesCount) mstore(delegates, sub(mload(delegates), decrease)) } } } /** * @inheritdoc IDelegateRegistryV1 */ function checkDelegateForAll(address delegate, address vault) public view override returns (bool) { bytes32 delegateHash = keccak256( abi.encode(delegate, vault, vaultVersion[vault], delegateVersion[vault][delegate]) ); return delegations[vault][vaultVersion[vault]].contains(delegateHash); } /** * @inheritdoc IDelegateRegistryV1 */ function checkDelegateForContract( address delegate, address vault, address contract_ ) public view override returns (bool) { bytes32 delegateHash = keccak256( abi.encode(delegate, vault, contract_, vaultVersion[vault], delegateVersion[vault][delegate]) ); return delegations[vault][vaultVersion[vault]].contains(delegateHash) ? true : checkDelegateForAll(delegate, vault); } /** * @inheritdoc IDelegateRegistryV1 */ function checkDelegateForToken( address delegate, address vault, address contract_, uint256 tokenId ) public view override returns (bool) { bytes32 delegateHash = keccak256( abi.encode(delegate, vault, contract_, tokenId, vaultVersion[vault], delegateVersion[vault][delegate]) ); return delegations[vault][vaultVersion[vault]].contains(delegateHash) ? true : checkDelegateForContract(delegate, vault, contract_); } }
// SPDX-License-Identifier: CC0-1.0 pragma solidity ^0.8.20; import {IDelegateRegistryV2 as IDelegateRegistry} from "../../../integrations/DelegateCash/IDelegateRegistryV2.sol"; import {RegistryHashes as Hashes} from "./libraries/RegistryHashes.sol"; import {RegistryStorage as Storage} from "./libraries/RegistryStorage.sol"; import {RegistryOps as Ops} from "./libraries/RegistryOps.sol"; /** * @title Test DelegateRegistry * * @dev Subset of full contract */ contract TestDelegateRegistryV2 is IDelegateRegistry { /// @dev Only this mapping should be used to verify delegations; the other mapping arrays are for enumerations mapping(bytes32 delegationHash => bytes32[5] delegationStorage) internal delegations; /// @dev Vault delegation enumeration outbox, for pushing new hashes only mapping(address from => bytes32[] delegationHashes) internal outgoingDelegationHashes; /// @dev Delegate enumeration inbox, for pushing new hashes only mapping(address to => bytes32[] delegationHashes) internal incomingDelegationHashes; /** * ----------- WRITE ----------- */ /// @inheritdoc IDelegateRegistry function delegateERC721( address to, address contract_, uint256 tokenId, bytes32 rights, bool enable ) external payable override returns (bytes32 hash) { hash = Hashes.erc721Hash(msg.sender, rights, to, tokenId, contract_); bytes32 location = Hashes.location(hash); address loadedFrom = _loadFrom(location); if (enable) { if (loadedFrom == Storage.DELEGATION_EMPTY) { _pushDelegationHashes(msg.sender, to, hash); _writeDelegationAddresses(location, msg.sender, to, contract_); _writeDelegation(location, Storage.POSITIONS_TOKEN_ID, tokenId); if (rights != "") _writeDelegation(location, Storage.POSITIONS_RIGHTS, rights); } else if (loadedFrom == Storage.DELEGATION_REVOKED) { _updateFrom(location, msg.sender); } } else if (loadedFrom == msg.sender) { _updateFrom(location, Storage.DELEGATION_REVOKED); } emit DelegateERC721(msg.sender, to, contract_, tokenId, rights, enable); } /** * ----------- CHECKS ----------- */ /// @inheritdoc IDelegateRegistry function checkDelegateForERC721( address to, address from, address contract_, uint256 tokenId, bytes32 rights ) external view override returns (bool valid) { if (!_invalidFrom(from)) { valid = _validateFrom(Hashes.allLocation(from, "", to), from) || _validateFrom(Hashes.contractLocation(from, "", to, contract_), from) || _validateFrom(Hashes.erc721Location(from, "", to, tokenId, contract_), from); if (!Ops.or(rights == "", valid)) { valid = _validateFrom(Hashes.allLocation(from, rights, to), from) || _validateFrom(Hashes.contractLocation(from, rights, to, contract_), from) || _validateFrom(Hashes.erc721Location(from, rights, to, tokenId, contract_), from); } } assembly ("memory-safe") { // Only first 32 bytes of scratch space is accessed mstore(0, iszero(iszero(valid))) // Compiler cleans dirty booleans on the stack to 1, so do the same here return(0, 32) // Direct return, skips Solidity's redundant copying to save gas } } /** * ----------- ENUMERATIONS ----------- */ /// @inheritdoc IDelegateRegistry function getOutgoingDelegations(address from) external view returns (Delegation[] memory delegations_) { delegations_ = _getValidDelegationsFromHashes(outgoingDelegationHashes[from]); } /** * ----------- ERC165 ----------- */ /// @notice Query if a contract implements an ERC-165 interface /// @param interfaceId The interface identifier /// @return valid Whether the queried interface is supported function supportsInterface(bytes4 interfaceId) external pure returns (bool) { return Ops.or(interfaceId == type(IDelegateRegistry).interfaceId, interfaceId == 0x01ffc9a7); } /** * ----------- INTERNAL ----------- */ /// @dev Helper function to push new delegation hashes to the incoming and outgoing hashes mappings function _pushDelegationHashes(address from, address to, bytes32 delegationHash) internal { outgoingDelegationHashes[from].push(delegationHash); incomingDelegationHashes[to].push(delegationHash); } /// @dev Helper function that writes bytes32 data to delegation data location at array position function _writeDelegation(bytes32 location, uint256 position, bytes32 data) internal { assembly { sstore(add(location, position), data) } } /// @dev Helper function that writes uint256 data to delegation data location at array position function _writeDelegation(bytes32 location, uint256 position, uint256 data) internal { assembly { sstore(add(location, position), data) } } /// @dev Helper function that writes addresses according to the packing rule for delegation storage function _writeDelegationAddresses(bytes32 location, address from, address to, address contract_) internal { (bytes32 firstSlot, bytes32 secondSlot) = Storage.packAddresses(from, to, contract_); uint256 firstPacked = Storage.POSITIONS_FIRST_PACKED; uint256 secondPacked = Storage.POSITIONS_SECOND_PACKED; assembly { sstore(add(location, firstPacked), firstSlot) sstore(add(location, secondPacked), secondSlot) } } /// @dev Helper function that writes `from` while preserving the rest of the storage slot function _updateFrom(bytes32 location, address from) internal { uint256 firstPacked = Storage.POSITIONS_FIRST_PACKED; uint256 cleanAddress = Storage.CLEAN_ADDRESS; uint256 cleanUpper12Bytes = type(uint256).max << 160; assembly { let slot := and(sload(add(location, firstPacked)), cleanUpper12Bytes) sstore(add(location, firstPacked), or(slot, and(from, cleanAddress))) } } /// @dev Helper function that takes an array of delegation hashes and returns an array of Delegation structs with their onchain information function _getValidDelegationsFromHashes( bytes32[] storage hashes ) internal view returns (Delegation[] memory delegations_) { uint256 count = 0; uint256 hashesLength = hashes.length; bytes32 hash; bytes32[] memory filteredHashes = new bytes32[](hashesLength); unchecked { for (uint256 i = 0; i < hashesLength; ++i) { hash = hashes[i]; if (_invalidFrom(_loadFrom(Hashes.location(hash)))) continue; filteredHashes[count++] = hash; } delegations_ = new Delegation[](count); bytes32 location; for (uint256 i = 0; i < count; ++i) { hash = filteredHashes[i]; location = Hashes.location(hash); (address from, address to, address contract_) = _loadDelegationAddresses(location); delegations_[i] = Delegation({ type_: Hashes.decodeType(hash), to: to, from: from, rights: _loadDelegationBytes32(location, Storage.POSITIONS_RIGHTS), amount: _loadDelegationUint(location, Storage.POSITIONS_AMOUNT), contract_: contract_, tokenId: _loadDelegationUint(location, Storage.POSITIONS_TOKEN_ID) }); } } } /// @dev Helper function that takes an array of delegation hashes and returns an array of valid delegation hashes function _getValidDelegationHashesFromHashes( bytes32[] storage hashes ) internal view returns (bytes32[] memory validHashes) { uint256 count = 0; uint256 hashesLength = hashes.length; bytes32 hash; bytes32[] memory filteredHashes = new bytes32[](hashesLength); unchecked { for (uint256 i = 0; i < hashesLength; ++i) { hash = hashes[i]; if (_invalidFrom(_loadFrom(Hashes.location(hash)))) continue; filteredHashes[count++] = hash; } validHashes = new bytes32[](count); for (uint256 i = 0; i < count; ++i) { validHashes[i] = filteredHashes[i]; } } } /// @dev Helper function that loads delegation data from a particular array position and returns as bytes32 function _loadDelegationBytes32(bytes32 location, uint256 position) internal view returns (bytes32 data) { assembly { data := sload(add(location, position)) } } /// @dev Helper function that loads delegation data from a particular array position and returns as uint256 function _loadDelegationUint(bytes32 location, uint256 position) internal view returns (uint256 data) { assembly { data := sload(add(location, position)) } } // @dev Helper function that loads the from address from storage according to the packing rule for delegation storage function _loadFrom(bytes32 location) internal view returns (address) { bytes32 data; uint256 firstPacked = Storage.POSITIONS_FIRST_PACKED; assembly { data := sload(add(location, firstPacked)) } return Storage.unpackAddress(data); } /// @dev Helper function to establish whether a delegation is enabled function _validateFrom(bytes32 location, address from) internal view returns (bool) { return (from == _loadFrom(location)); } /// @dev Helper function that loads the address for the delegation according to the packing rule for delegation storage function _loadDelegationAddresses( bytes32 location ) internal view returns (address from, address to, address contract_) { bytes32 firstSlot; bytes32 secondSlot; uint256 firstPacked = Storage.POSITIONS_FIRST_PACKED; uint256 secondPacked = Storage.POSITIONS_SECOND_PACKED; assembly { firstSlot := sload(add(location, firstPacked)) secondSlot := sload(add(location, secondPacked)) } (from, to, contract_) = Storage.unpackAddresses(firstSlot, secondSlot); } function _invalidFrom(address from) internal pure returns (bool) { return Ops.or(from == Storage.DELEGATION_EMPTY, from == Storage.DELEGATION_REVOKED); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "../../rates/WeightedInterestRateModel.sol"; /** * @title Test Contract Wrapper for WeightedInterestRateModel * @author MetaStreet Labs */ contract TestWeightedInterestRateModel is WeightedInterestRateModel { /**************************************************************************/ /* Constructor */ /**************************************************************************/ constructor() WeightedInterestRateModel() {} /**************************************************************************/ /* Wrapper for Primary API */ /**************************************************************************/ /** * @dev External wrapper for _price() */ function price( uint256 principal, uint64 duration, LiquidityLogic.NodeSource[] memory nodes, uint16 count, uint64[] memory rates, uint32 adminFeeRate ) external pure returns (uint256, uint256, uint128[] memory) { (uint256 repayment, uint256 adminFee) = _price(principal, duration, nodes, count, rates, adminFeeRate); uint128[] memory pending = new uint128[](count); for (uint256 i; i < count; i++) { pending[i] = nodes[i].pending; } return (repayment, adminFee, pending); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/proxy/Clones.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol"; import "../LoanReceipt.sol"; import "../interfaces/ICollateralLiquidator.sol"; import "../interfaces/ICollateralLiquidationReceiver.sol"; /** * @title Testing Jig for Collateral Liquidators * @author MetaStreet Labs */ contract TestCollateralLiquidatorJig is ERC165, ERC721Holder, ICollateralLiquidationReceiver { using SafeERC20 for IERC20; /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Force a revert */ error ForceRevert(); /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when loan collateral is liquidated * @param proceeds Liquidation proceeds in currency tokens */ event CollateralLiquidated(uint256 proceeds); /**************************************************************************/ /* State */ /**************************************************************************/ /** * @dev Currency token */ IERC20 private _currencyToken; /** * @dev Collateral liquidator instance */ address private _collateralLiquidator; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice TestLiquidator */ constructor(IERC20 currencyToken_, address collateralLiquidator_) { _currencyToken = currencyToken_; _collateralLiquidator = collateralLiquidator_; } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @notice Get currency token * @return Currency token contract */ function currencyToken() external view returns (address) { return address(_currencyToken); } /** * @notice Get collateral liquidator * @return Collateral liquidator contract */ function collateralLiquidator() external view returns (address) { return address(_collateralLiquidator); } /**************************************************************************/ /* Methods */ /**************************************************************************/ /** * @notice Liquidate collateral with liquidator * @param encodedLoanReceipt Encoded loan receipt */ function liquidate(bytes calldata encodedLoanReceipt) external { LoanReceipt.LoanReceiptV2 memory loanReceipt = LoanReceipt.decode(encodedLoanReceipt); IERC721(loanReceipt.collateralToken).approve(_collateralLiquidator, loanReceipt.collateralTokenId); /* Start liquidation with collateral liquidator */ ICollateralLiquidator(_collateralLiquidator).liquidate( address(_currencyToken), loanReceipt.collateralToken, loanReceipt.collateralTokenId, loanReceipt.collateralWrapperContext, encodedLoanReceipt ); } /** * @notice Callback on loan collateral liquidated * @param loanReceipt Loan receipt * @param proceeds Liquidation proceeds in currency tokens */ function onCollateralLiquidated(bytes calldata loanReceipt, uint256 proceeds) external { LoanReceipt.LoanReceiptV2 memory decodedLoanReceipt = LoanReceipt.decode(loanReceipt); /* Force a revert to test try...catch in English Auction */ if (decodedLoanReceipt.collateralTokenId == 130) { revert ForceRevert(); } emit CollateralLiquidated(proceeds); } /******************************************************/ /* ERC165 interface */ /******************************************************/ /** * @inheritdoc IERC165 */ function supportsInterface(bytes4 interfaceId) public view override returns (bool) { return interfaceId == type(ICollateralLiquidationReceiver).interfaceId || super.supportsInterface(interfaceId); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol"; import "../LoanReceipt.sol"; import "../interfaces/ICollateralLiquidator.sol"; /** * @title Truncated Testing Jig for Collateral Liquidators * @author MetaStreet Labs */ contract TestCollateralLiquidatorJigTruncated is ERC721Holder { using SafeERC20 for IERC20; /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when loan collateral is liquidated * @param proceeds Liquidation proceeds in currency tokens */ event CollateralLiquidated(uint256 proceeds); /**************************************************************************/ /* State */ /**************************************************************************/ /** * @dev Currency token */ IERC20 private _currencyToken; /** * @dev Collateral liquidator instance */ address private _collateralLiquidator; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice TestLiquidator */ constructor(IERC20 currencyToken_, address collateralLiquidator_) { _currencyToken = currencyToken_; _collateralLiquidator = collateralLiquidator_; } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @notice Get currency token * @return Currency token contract */ function currencyToken() external view returns (address) { return address(_currencyToken); } /** * @notice Get collateral liquidator * @return Collateral liquidator contract */ function collateralLiquidator() external view returns (address) { return address(_collateralLiquidator); } /**************************************************************************/ /* Methods */ /**************************************************************************/ /** * @notice Liquidate collateral with liquidator * @param encodedLoanReceipt Encoded loan receipt */ function liquidate(bytes calldata encodedLoanReceipt) external { LoanReceipt.LoanReceiptV2 memory loanReceipt = LoanReceipt.decode(encodedLoanReceipt); IERC721(loanReceipt.collateralToken).approve(_collateralLiquidator, loanReceipt.collateralTokenId); /* Start liquidation with collateral liquidator */ ICollateralLiquidator(_collateralLiquidator).liquidate( address(_currencyToken), loanReceipt.collateralToken, loanReceipt.collateralTokenId, loanReceipt.collateralWrapperContext, encodedLoanReceipt ); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "../interfaces/ILiquidity.sol"; import "../LiquidityLogic.sol"; /** * @title Test Contract Wrapper for LiquidityLogic * @author MetaStreet Labs */ contract TestLiquidityLogic is ILiquidity { using LiquidityLogic for LiquidityLogic.Liquidity; /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted with return value from deposit() * @param shares Shares created */ event Deposited(uint128 shares); /** * @notice Emitted with return values from redeem() * @param index Redemption index * @param target Redemption target */ event RedemptionTarget(uint128 index, uint128 target); /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Liquidity */ LiquidityLogic.Liquidity internal _liquidity; /**************************************************************************/ /* Constructor */ /**************************************************************************/ constructor() { _liquidity.initialize(); } /**************************************************************************/ /* ILiquidity Getters */ /**************************************************************************/ /** * @inheritdoc ILiquidity */ function liquidityNodes(uint128 startTick, uint128 endTick) external view returns (ILiquidity.NodeInfo[] memory) { return _liquidity.liquidityNodes(startTick, endTick); } /** * @inheritdoc ILiquidity */ function liquidityNode(uint128 tick) external view returns (ILiquidity.NodeInfo memory) { return _liquidity.liquidityNode(tick); } /** * @inheritdoc ILiquidity */ function liquidityNodeWithAccrual( uint128 tick ) external view returns (ILiquidity.NodeInfo memory, ILiquidity.AccrualInfo memory) { return _liquidity.liquidityNodeWithAccrual(tick); } /** * @inheritdoc ILiquidity */ function depositSharePrice(uint128 tick) external view returns (uint256) { return _liquidity.depositSharePrice(tick); } /** * @inheritdoc ILiquidity */ function redemptionSharePrice(uint128 tick) external view returns (uint256) { return _liquidity.redemptionSharePrice(tick); } /**************************************************************************/ /* Wrapper for Primary API */ /**************************************************************************/ /** * @dev External wrapper function for LiquidityLogic.redemptionAvailable() */ function redemptionAvailable( uint128 tick, uint128 pending, uint128 index, uint128 target ) external view returns (uint128 shares, uint128 amount) { (shares, amount, , ) = _liquidity.redemptionAvailable(tick, pending, index, target); } /** * @dev External wrapper function for LiquidityLogic._instantiate() */ function instantiate(uint128 tick) external { return _liquidity._instantiate(_liquidity.nodes[tick], tick); } /** * @dev External wrapper function for LiquidityLogic.deposit() */ function deposit(uint128 tick, uint128 amount) external returns (uint256) { uint128 shares = _liquidity.deposit(tick, amount); emit Deposited(shares); return shares; } /** * @dev External wrapper function for LiquidityLogic.use() */ function use(uint128 tick, uint128 amount, uint128 pending, uint64 duration) external { _liquidity.use(tick, amount, pending, duration); } /** * @dev External wrapper function for LiquidityLogic.restore() */ function restore( uint128 tick, uint128 used, uint128 pending, uint128 restored, uint64 duration, uint64 elapsed ) external { _liquidity.restore(tick, used, pending, restored, duration, elapsed); } /** * @dev External wrapper function for LiquidityLogic.redeem() */ function redeem(uint128 tick, uint128 shares) external returns (uint128, uint128) { (uint128 index, uint128 target) = _liquidity.redeem(tick, shares); emit RedemptionTarget(index, target); return (index, target); } /** * @dev External wrapper function for LiquidityLogic.source() */ function source( uint256 amount, uint128[] calldata ticks, uint256 multiplier, uint256 durationIndex ) external view returns (LiquidityLogic.NodeSource[] memory, uint16 count) { return _liquidity.source(amount, ticks, multiplier, durationIndex); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "../interfaces/ILiquidity.sol"; import "../LoanReceipt.sol"; /** * @title Test Contract Wrapper for LoanReceipt Library * @author MetaStreet Labs */ contract TestLoanReceipt { /** * @dev External wrapper function for LoanReceipt.hash() */ function hash(bytes calldata encodedReceipt) external view returns (bytes32) { return LoanReceipt.hash(encodedReceipt); } /** * @dev External wrapper function for LoanReceipt.encode() */ function encode(LoanReceipt.LoanReceiptV2 memory receipt) external pure returns (bytes memory) { return LoanReceipt.encode(receipt); } /** * @dev External wrapper function for LoanReceipt.decode() */ function decode(bytes calldata encodedReceipt) external pure returns (LoanReceipt.LoanReceiptV2 memory) { return LoanReceipt.decode(encodedReceipt); } }
// SPDX-License-Identifier: Unlicense pragma solidity 0.8.20; import "@openzeppelin/contracts/proxy/Proxy.sol"; import "@openzeppelin/contracts/utils/Address.sol"; /** * @title Test proxy for peripheral contracts * @author MetaStreet Labs */ contract TestProxy is Proxy { /** * @dev Space for implementation storage */ uint256[128] private __reserved; /** * @dev Implementation contract */ address private _impl; /** * @notice TestProxy constructor * @param implementation Implementation contract * @param data Initialization calldata */ constructor(address implementation, bytes memory data) { _impl = implementation; Address.functionDelegateCall(implementation, data); } /* * @dev Proxy implementation address hook */ function _implementation() internal view virtual override returns (address) { return _impl; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "../Tick.sol"; /** * @title Test Contract Wrapper for Tick Library * @author MetaStreet Labs */ contract TestTick { /** * @dev External wrapper function for Tick.decode() */ function decode( uint128 tick ) external pure returns (uint256 limit, uint256 duration, uint256 rate, uint256 reserved) { return Tick.decode(tick); } /** * @dev External wrapper function for Tick.validate() */ function validate(uint128 tick, uint256 minLimit, uint256 minDurationIndex) external pure returns (uint256) { return Tick.validate(tick, minLimit, minDurationIndex); } /** * @dev External wrapper function for Tick.validate() */ function validate( uint128 tick, uint256 minLimit, uint256 minDurationIndex, uint256 maxDurationIndex, uint256 minRateIndex, uint256 maxRateIndex ) external pure { return Tick.validate(tick, minLimit, minDurationIndex, maxDurationIndex, minRateIndex, maxRateIndex); } }
// SPDX-License-Identifier: Unlicense pragma solidity 0.8.20; import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; /** * @title Test ERC1155 Token */ contract TestERC1155 is ERC1155, Ownable { /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice TestERC1155 constructor * @notice name Token name * @notice symbol Token symbol * @notice baseURI Token base URI */ constructor(string memory uri) ERC1155(uri) {} /**************************************************************************/ /* Privileged API */ /**************************************************************************/ /** * @notice Set token URI * @param uri Token URI */ function setURI(string memory uri) external onlyOwner { _setURI(uri); } /** * @notice Mint tokens to account * @param to Recipient account * @param tokenId Token ID * @param amount Amount * @param data Data */ function mint(address to, uint256 tokenId, uint256 amount, bytes memory data) external virtual onlyOwner { _mint(to, tokenId, amount, data); } /** * @notice Batch mint tokens to account * @param to Recipient account * @param tokenIds Token IDs * @param amounts Amounts * @param data Data */ function mintBatch( address to, uint256[] memory tokenIds, uint256[] memory amounts, bytes memory data ) external virtual onlyOwner { _mintBatch(to, tokenIds, amounts, data); } /** * @notice Burn tokens * @param tokenId Token ID * @param amount Amount */ function burn(uint256 tokenId, uint256 amount) external onlyOwner { _burn(msg.sender, tokenId, amount); } /** * @notice Batch burn tokens * @param tokenIds Token ID * @param amounts Amount */ function burnBatch(uint256[] memory tokenIds, uint256[] memory amounts) external onlyOwner { _burnBatch(msg.sender, tokenIds, amounts); } }
// SPDX-License-Identifier: Unlicense pragma solidity 0.8.20; import "@openzeppelin/contracts/token/ERC20/presets/ERC20PresetFixedSupply.sol"; /** * @title Test ERC20 Token */ contract TestERC20 is ERC20PresetFixedSupply { /**************************************************************************/ /* Properties */ /**************************************************************************/ uint8 private _decimals; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice TestERC20 constructor * @notice name Token name * @notice symbol Token symbol * @notice decimals Token decimals * @notice initialSupply Initial supply */ constructor( string memory name, string memory symbol, uint8 decimals_, uint256 initialSupply ) ERC20PresetFixedSupply(name, symbol, initialSupply, msg.sender) { _decimals = decimals_; } /**************************************************************************/ /* Overrides */ /**************************************************************************/ /** * @inheritdoc ERC20 */ function decimals() public view override returns (uint8) { return _decimals; } }
// SPDX-License-Identifier: Unlicense pragma solidity 0.8.20; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; /** * @title Test ERC721 Token */ contract TestERC721 is ERC721, Ownable { /**************************************************************************/ /* Properties */ /**************************************************************************/ string private _baseTokenURI; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice TestERC721 constructor * @notice name Token name * @notice symbol Token symbol * @notice baseURI Token base URI */ constructor(string memory name, string memory symbol, string memory baseURI) ERC721(name, symbol) { _baseTokenURI = baseURI; } /**************************************************************************/ /* Overrides */ /**************************************************************************/ /** * @inheritdoc ERC721 */ function _baseURI() internal view virtual override returns (string memory) { return _baseTokenURI; } /**************************************************************************/ /* Privileged API */ /**************************************************************************/ /** * @notice Set token base URI * @param baseURI Token base URI */ function setBaseURI(string memory baseURI) external onlyOwner { _baseTokenURI = baseURI; } /** * @notice Mint token to account * @param to Recipient account * @param tokenId Token ID */ function mint(address to, uint256 tokenId) external virtual onlyOwner { _safeMint(to, tokenId); } /** * @notice Burn token * @param tokenId Token ID */ function burn(uint256 tokenId) external onlyOwner { _burn(tokenId); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "../../Pool.sol"; contract TestMaliciousERC20 { /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Fixed point scale */ uint256 internal constant FIXED_POINT_SCALE = 1e18; /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice MetaStreet V2 Pool */ Pool internal _pool; /** * @notice Deposit tick */ uint128 internal _tick; /**************************************************************************/ /* Constructor */ /**************************************************************************/ constructor(address pool_, uint128 tick_) { _pool = Pool(pool_); _tick = tick_; } /**************************************************************************/ /* IERC20 API */ /**************************************************************************/ function transfer(address to, uint256 value) public returns (bool) { _pool.transfer(msg.sender, to, _tick, value); return true; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; /** * @title Tick * @author MetaStreet Labs */ library Tick { /* * A tick encodes three conditions on liquidity: limit, duration, and rate. * Limit is the maximum depth that liquidity sourced from the node can be * used in. Duration is the maximum allowed duration for that liquidity. * Rate is the interest rate associated with that liquidity. Duration and * rates are encoded as indexes into predetermined, discrete tiers. * * +-----------------------------------------------------------------------+ * | 128 | * +--------------------------------------|----------|----------|----------+ * | 120 | 3 | 3 | 2 | * | Limit | Dur. Idx | Rate Idx | Reserved | * +-----------------------------------------------------------------------+ * * Duration Index is ordered from longest duration to shortest, e.g. 30 * days, 14 days, 7 days. * * Rate Index is ordered from lowest rate to highest rate, e.g. 10%, 30%, * 50%. */ /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Tick limit mask */ uint256 internal constant TICK_LIMIT_MASK = 0xffffffffffffffffffffffffffffff; /** * @notice Tick limit shift */ uint256 internal constant TICK_LIMIT_SHIFT = 8; /** * @notice Tick duration index mask */ uint256 internal constant TICK_DURATION_MASK = 0x7; /** * @notice Tick duration index shift */ uint256 internal constant TICK_DURATION_SHIFT = 5; /** * @notice Tick rate index mask */ uint256 internal constant TICK_RATE_MASK = 0x7; /** * @notice Tick rate index shift */ uint256 internal constant TICK_RATE_SHIFT = 2; /** * @notice Tick reserved mask */ uint256 internal constant TICK_RESERVED_MASK = 0x3; /** * @notice Tick reserved shift */ uint256 internal constant TICK_RESERVED_SHIFT = 0; /** * @notice Maximum number of durations supported */ uint256 internal constant MAX_NUM_DURATIONS = TICK_DURATION_MASK + 1; /** * @notice Maximum number of rates supported */ uint256 internal constant MAX_NUM_RATES = TICK_RATE_MASK + 1; /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid tick */ error InvalidTick(); /**************************************************************************/ /* Helper Functions */ /**************************************************************************/ /** * @dev Decode a Tick * @param tick Tick * @return limit Limit field * @return duration Duration field * @return rate Rate field * @return reserved Reserved field */ function decode( uint128 tick ) internal pure returns (uint256 limit, uint256 duration, uint256 rate, uint256 reserved) { limit = ((tick >> TICK_LIMIT_SHIFT) & TICK_LIMIT_MASK); duration = ((tick >> TICK_DURATION_SHIFT) & TICK_DURATION_MASK); rate = ((tick >> TICK_RATE_SHIFT) & TICK_RATE_MASK); reserved = ((tick >> TICK_RESERVED_SHIFT) & TICK_RESERVED_MASK); } /** * @dev Validate a Tick (fast) * @param tick Tick * @param prevTick Previous tick * @param maxDurationIndex Maximum Duration Index (inclusive) * @return Limit field */ function validate(uint128 tick, uint256 prevTick, uint256 maxDurationIndex) internal pure returns (uint256) { (uint256 limit, uint256 duration, , ) = decode(tick); if (tick <= prevTick) revert InvalidTick(); if (duration > maxDurationIndex) revert InvalidTick(); return limit; } /** * @dev Validate a Tick (slow) * @param tick Tick * @param minLimit Minimum Limit (exclusive) * @param minDurationIndex Minimum Duration Index (inclusive) * @param maxDurationIndex Maximum Duration Index (inclusive) * @param minRateIndex Minimum Rate Index (inclusive) * @param maxRateIndex Maximum Rate Index (inclusive) */ function validate( uint128 tick, uint256 minLimit, uint256 minDurationIndex, uint256 maxDurationIndex, uint256 minRateIndex, uint256 maxRateIndex ) internal pure { (uint256 limit, uint256 duration, uint256 rate, uint256 reserved) = decode(tick); if (limit <= minLimit) revert InvalidTick(); if (duration < minDurationIndex) revert InvalidTick(); if (duration > maxDurationIndex) revert InvalidTick(); if (rate < minRateIndex) revert InvalidTick(); if (rate > maxRateIndex) revert InvalidTick(); if (reserved != 0) revert InvalidTick(); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title Deposit Token API * @author MetaStreet Labs */ abstract contract DepositToken { /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when deposit token created * @param instance Instance address * @param implementation Implementation address * @param tick Tick */ event TokenCreated(address indexed instance, address indexed implementation, uint128 indexed tick); /**************************************************************************/ /* API */ /**************************************************************************/ /** * @notice Get the deposit token address for tick * * @param tick Tick * @return Deposit token address */ function depositToken(uint128 tick) public view virtual returns (address); /** * @notice Tokenize a tick * * @param tick Tick * @return Deposit token address */ function _tokenize(uint128 tick) internal virtual returns (address); /** * @notice Hook called by Pool on token transfers * * @param from From * @param to To * @param tick Tick * @param shares Shares */ function _onExternalTransfer(address from, address to, uint128 tick, uint256 shares) internal virtual; }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "./DepositToken.sol"; import "./ERC20DepositTokenFactory.sol"; import "./ERC20DepositTokenImplementation.sol"; /** * @title ERC20 Deposit Token * @author MetaStreet Labs */ contract ERC20DepositToken is DepositToken { /**************************************************************************/ /* Structures */ /**************************************************************************/ /** * @custom:storage-location erc7201:erc20DepositToken.depositTokenStorage */ struct DepositTokenStorage { /* Mapping of tick to token address */ mapping(uint128 => address) tokens; } /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Current ERC20 deposit token implementation */ address internal immutable _implementation; /** * @notice Deposit token storage slot * @dev keccak256(abi.encode(uint256(keccak256("erc20DepositToken.depositTokenStorage")) - 1)) & ~bytes32(uint256(0xff)); */ bytes32 private constant DEPOSIT_TOKEN_STORAGE_LOCATION = 0xc61d9ab4916a5eab6b572dc8707662b99e55e17ecdc61af8ff79465ad64ded00; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice ERC20DepositToken constructor * * @param implementation_ ERC20 deposit token implementation address */ constructor(address implementation_) { _implementation = implementation_; } /**************************************************************************/ /* Internal Helpers */ /**************************************************************************/ /** * @notice Get reference to ERC-7201 deposit token storage * * @return $ Reference to deposit token storage */ function _getDepositTokenStorage() private pure returns (DepositTokenStorage storage $) { assembly { $.slot := DEPOSIT_TOKEN_STORAGE_LOCATION } } /**************************************************************************/ /* API */ /**************************************************************************/ /** * @notice Get ERC20 Deposit Token implementation address * * @return ERC20 Deposit Token implementation address */ function getERC20DepositTokenImplementation() external view returns (address) { return _implementation; } /** * @notice Tokenize a tick * * @param tick Tick */ function _tokenize(uint128 tick) internal override returns (address) { /* Return token if it already exists */ address tokenInstance = depositToken(tick); if (tokenInstance != address(0)) { emit TokenCreated(tokenInstance, _implementation, tick); return tokenInstance; } /* Create proxied token */ tokenInstance = ERC20DepositTokenFactory.deploy(tick); /* Store token instance in mapping */ _getDepositTokenStorage().tokens[tick] = tokenInstance; emit TokenCreated(tokenInstance, _implementation, tick); return tokenInstance; } /** * @inheritdoc DepositToken */ function depositToken(uint128 tick) public view override returns (address) { return _getDepositTokenStorage().tokens[tick]; } /** * @inheritdoc DepositToken */ function _onExternalTransfer(address from, address to, uint128 tick, uint256 shares) internal override { /* No operation if token does not exist */ if (depositToken(tick) == address(0)) return; /* Call external transfer hook */ ERC20DepositTokenImplementation(depositToken(tick)).onExternalTransfer(from, to, shares); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/utils/Create2.sol"; import "./ERC20DepositTokenProxy.sol"; /** * @title ERC20 Deposit Token Factory * @author MetaStreet Labs */ library ERC20DepositTokenFactory { /** * @notice Deploy a proxied ERC20 deposit token * @param tick Tick * @return Proxy address */ function deploy(uint128 tick) external returns (address) { /* Create init data */ bytes memory initData = abi.encode( address(this), abi.encodeWithSignature("initialize(bytes)", abi.encode(tick)) ); /* Create token instance */ return Create2.deploy( 0, bytes32(uint256(tick)), abi.encodePacked(type(ERC20DepositTokenProxy).creationCode, initData) ); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/interfaces/IERC20Metadata.sol"; import "@openzeppelin/contracts/interfaces/IERC721Metadata.sol"; import "@openzeppelin/contracts/utils/math/SafeCast.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import "../Pool.sol"; import "../interfaces/ILiquidity.sol"; /** * @title ERC20 Deposit Token Implementation * @author MetaStreet Labs */ contract ERC20DepositTokenImplementation is IERC20Metadata { using Tick for uint128; using SafeCast for uint256; /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice ERC20 Errors from OpenZeppelin implementation: * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.0/contracts/interfaces/draft-IERC6093.sol */ /** * @notice Insufficient balance * * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @notice Insufficient allowance * * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @notice Invalid spender * * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSpender(address sender); /** * @notice Invalid Sender * * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @notice Invalid Receiver * * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @notice Invalid caller */ error InvalidCaller(); /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Implementation version */ string public constant IMPLEMENTATION_VERSION = "1.0"; /** * @notice Fixed point scale */ uint256 internal constant FIXED_POINT_SCALE = 1e18; /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Initialized boolean */ bool internal _initialized; /** * @notice MetaStreet V2 Pool */ Pool internal _pool; /** * @notice Deposit tick */ uint128 internal _tick; /** * @notice Owner => operator => allowance */ mapping(address => mapping(address => uint256)) private _allowances; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice ERC20 Deposit Token Implementation constructor */ constructor() { /* Disable initialization of implementation contract */ _initialized = true; } /**************************************************************************/ /* Initializer */ /**************************************************************************/ /** * @notice Initializer * @param params ABI-encoded parameters */ function initialize(bytes memory params) external { require(!_initialized, "Already initialized"); _initialized = true; /* Decode parameters */ uint128 tick_ = abi.decode(params, (uint128)); _pool = Pool(msg.sender); _tick = tick_; } /**************************************************************************/ /* Internal Helpers */ /**************************************************************************/ /** * @notice Helper function to get rounded loan limit for name() and symbol() * * @dev Solely utilized to generate rounded number in name() and symbol() getters. * Loan limits > 1 ETH are rounded to the nearest whole number. Under 1 ETH * are rounded to the nearest hundredth place. * * @param loanLimit_ Loan limit as uint256 * * @return Loan limit as string */ function _getLoanLimit(uint256 loanLimit_) internal pure returns (string memory) { /* Handle loan limits > 1 ETH */ if (loanLimit_ >= FIXED_POINT_SCALE) { return Strings.toString((loanLimit_ + (FIXED_POINT_SCALE / 2)) / FIXED_POINT_SCALE); } else { /* Handle loan limits < 1 ETH */ uint256 scaledValue = loanLimit_ * 100; uint256 integer = scaledValue / FIXED_POINT_SCALE; if (scaledValue % FIXED_POINT_SCALE >= FIXED_POINT_SCALE / 2) { integer += 1; } uint256 hundredthPlaces = integer % 100; string memory decimalStr = hundredthPlaces < 10 ? string.concat("0", Strings.toString(hundredthPlaces)) : Strings.toString(hundredthPlaces); return string.concat("0.", decimalStr); } } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @inheritdoc IERC20Metadata */ function name() public view returns (string memory) { (uint256 limit_, , , ) = _tick.decode(); return string.concat( "MetaStreet V2 Deposit: ", IERC721Metadata(_pool.collateralToken()).symbol(), "-", IERC20Metadata(_pool.currencyToken()).symbol(), ":", _getLoanLimit(limit_) ); } /** * @inheritdoc IERC20Metadata */ function symbol() public view returns (string memory) { (uint256 limit_, , , ) = _tick.decode(); return string.concat( "m", IERC20Metadata(_pool.currencyToken()).symbol(), "-", IERC721Metadata(_pool.collateralToken()).symbol(), ":", _getLoanLimit(limit_) ); } /** * @inheritdoc IERC20Metadata */ function decimals() public view virtual returns (uint8) { return 18; } /** * @notice Pool * @return Pool address */ function pool() external view returns (Pool) { return _pool; } /** * @notice Tick * @return Encoded tick */ function tick() external view returns (uint128) { return _tick; } /** * @notice Tick loan limit * @return Loan limit in currency tokens */ function limit() external view returns (uint128) { (uint256 limit_, , , ) = _tick.decode(); return limit_.toUint128(); } /** * @notice Tick duration * @return Duration in seconds */ function duration() external view returns (uint64) { (, uint256 durationIndex, , ) = _tick.decode(); return _pool.durations()[durationIndex]; } /** * @notice Tick rate * @return Rate in interest per second */ function rate() external view returns (uint64) { (, , uint256 rateIndex, ) = _tick.decode(); return _pool.rates()[rateIndex]; } /** * @notice Currency token * @return Address of currency token */ function currencyToken() external view returns (address) { return _pool.currencyToken(); } /** * @notice Deposit share price * @return Deposit share price */ function depositSharePrice() external view returns (uint256) { return _pool.depositSharePrice(_tick); } /** * @notice Redemption share price * @return Redemption share price */ function redemptionSharePrice() external view returns (uint256) { return _pool.redemptionSharePrice(_tick); } /**************************************************************************/ /* Internal Helpers */ /**************************************************************************/ /** * @notice Helper function to transfer tokens * * @param from From * @param to To * @param value Value */ function _transfer(address from, address to, uint256 value) internal { /* No transfer to zero address */ if (to == address(0)) { revert ERC20InvalidReceiver(address(0)); } /* Validate balance */ uint256 fromBalance = balanceOf(from); if (fromBalance < value) { revert ERC20InsufficientBalance(from, fromBalance, value); } /* Call transfer on pool */ _pool.transfer(from, to, _tick, value); emit Transfer(from, to, value); } /**************************************************************************/ /* Hooks */ /**************************************************************************/ /** * @notice External transfer hook * * @param from From * @param to To * @param value Value */ function onExternalTransfer(address from, address to, uint256 value) external { if (msg.sender != address(_pool)) revert InvalidCaller(); emit Transfer(from, to, value); } /**************************************************************************/ /* IERC20 API */ /**************************************************************************/ /** * @inheritdoc IERC20 */ function totalSupply() public view returns (uint256) { /* Get Pool node */ ILiquidity.NodeInfo memory node = _pool.liquidityNode(_tick); /* Calculate total supply */ return node.shares - node.redemptions; } /** * @inheritdoc IERC20 */ function balanceOf(address account) public view returns (uint256) { /* Get shares from deposits */ (uint128 shares, ) = _pool.deposits(account, _tick); return shares; } /** * @inheritdoc IERC20 */ function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } /** * @inheritdoc IERC20 */ function approve(address spender, uint256 value) public returns (bool) { if (spender == address(0)) { revert ERC20InvalidSpender(address(0)); } _allowances[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true; } /** * @inheritdoc IERC20 */ function transfer(address to, uint256 value) public returns (bool) { _transfer(msg.sender, to, value); return true; } /** * @inheritdoc IERC20 */ function transferFrom(address from, address to, uint256 value) public returns (bool) { /* No transfer from zero address */ if (from == address(0)) { revert ERC20InvalidSender(address(0)); } /* Check + update allowance */ uint256 currentAllowance = allowance(from, msg.sender); if (currentAllowance != type(uint256).max) { if (currentAllowance < value) { revert ERC20InsufficientAllowance(msg.sender, currentAllowance, value); } unchecked { _allowances[from][msg.sender] = currentAllowance - value; } } _transfer(from, to, value); return true; } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/proxy/Proxy.sol"; import "@openzeppelin/contracts/utils/Address.sol"; import "./ERC20DepositToken.sol"; /** * @title ERC20 Deposit Token Proxy * @author MetaStreet Labs */ contract ERC20DepositTokenProxy is Proxy { /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Beacon address (ERC20DepositToken) */ address internal immutable _beacon; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice ERC20DepositTokenProxy constructor * * @dev Set the ERC20DepositToken address as beacon * and initializes the storage of the Proxy * * @param beacon Beacon address * @param data Initialization data */ constructor(address beacon, bytes memory data) { _beacon = beacon; Address.functionDelegateCall(ERC20DepositToken(beacon).getERC20DepositTokenImplementation(), data); } /**************************************************************************/ /* Getters */ /**************************************************************************/ /** * @notice Get implementation address * * @dev Overrides Proxy._implementation() * * @return Implementation address */ function _implementation() internal view virtual override returns (address) { return ERC20DepositToken(_beacon).getERC20DepositTokenImplementation(); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.20; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "../interfaces/ICollateralWrapper.sol"; /** * @title Bundle Collateral Wrapper * @author MetaStreet Labs */ contract BundleCollateralWrapper is ICollateralWrapper, ERC721, ReentrancyGuard { /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Implementation version */ string public constant IMPLEMENTATION_VERSION = "2.1"; /** * @notice Maximum bundle size */ uint256 internal constant MAX_BUNDLE_SIZE = 32; /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid caller */ error InvalidCaller(); /** * @notice Invalid context */ error InvalidContext(); /** * @notice Invalid bundle size */ error InvalidSize(); /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when bundle is minted * @param tokenId Token ID of the new collateral wrapper token * @param account Address that created the bundle * @param encodedBundle Encoded bundle data */ event BundleMinted(uint256 indexed tokenId, address indexed account, bytes encodedBundle); /** * @notice Emitted when bundle is unwrapped * @param tokenId Token ID of the bundle collateral wrapper token * @param account Address that unwrapped the bundle */ event BundleUnwrapped(uint256 indexed tokenId, address indexed account); /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice BundleCollateralWrapper constructor */ constructor() ERC721("MetaStreet Bundle Collateral Wrapper", "MSBCW") {} /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc ICollateralWrapper */ function name() public pure override(ERC721, ICollateralWrapper) returns (string memory) { return "MetaStreet Bundle Collateral Wrapper"; } /** * @inheritdoc ERC721 */ function symbol() public pure override returns (string memory) { return "MSBCW"; } /** * @notice Check if token ID exists * @param tokenId Token ID * @return True if token ID exists, otherwise false */ function exists(uint256 tokenId) external view returns (bool) { return _exists(tokenId); } /** * @inheritdoc ICollateralWrapper */ function enumerate( uint256 tokenId, bytes calldata context ) external view returns (address token, uint256[] memory tokenIds) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Get token address from context */ token = address(uint160(bytes20(context[0:20]))); /* Compute number of tokens in context */ uint256 tokenCount = (context.length - 20) / 32; /* Instantiate asset info array */ tokenIds = new uint256[](tokenCount); /* Populate asset info array */ uint256 offset = 20; for (uint256 i; i < tokenCount; i++) { tokenIds[i] = uint256(bytes32(context[offset:offset + 32])); offset += 32; } } /** * @inheritdoc ICollateralWrapper */ function enumerateWithQuantities( uint256 tokenId, bytes calldata context ) external view returns (address token, uint256[] memory tokenIds, uint256[] memory quantities) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Get token address from context */ token = address(uint160(bytes20(context[0:20]))); /* Compute number of tokens in context */ uint256 tokenCount = (context.length - 20) / 32; /* Instantiate asset info array */ tokenIds = new uint256[](tokenCount); /* Instantiate quantities array */ quantities = new uint256[](tokenCount); /* Populate arrays */ uint256 offset = 20; for (uint256 i; i < tokenCount; i++) { tokenIds[i] = uint256(bytes32(context[offset:offset + 32])); quantities[i] = 1; offset += 32; } } /** * @inheritdoc ICollateralWrapper */ function count(uint256 tokenId, bytes calldata context) external view returns (uint256) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Compute number of tokens in context */ return (context.length - 20) / 32; } /** * @inheritdoc ICollateralWrapper */ function transferCalldata( address token, address from, address to, uint256 tokenId, uint256 ) external pure returns (address, bytes memory) { return (token, abi.encodeWithSelector(IERC721.transferFrom.selector, from, to, tokenId)); } /**************************************************************************/ /* Internal Helpers */ /**************************************************************************/ /** * @dev Compute hash of encoded bundle * @param encodedBundle Encoded bundle * @return bundleTokenId Hash */ function _hash(bytes memory encodedBundle) internal view returns (bytes32) { /* Take hash of chain ID (32 bytes) concatenated with encoded bundle */ return keccak256(abi.encodePacked(block.chainid, encodedBundle)); } /**************************************************************************/ /* User API */ /**************************************************************************/ /** * @notice Deposit NFT collateral into contract and mint a BundleCollateralWrapper token * * Emits a {BundleMinted} event * * @dev Collateral token and token ids are encoded, hashed and stored as * the BundleCollateralWrapper token ID. * @param token Collateral token address * @param tokenIds List of token IDs */ function mint(address token, uint256[] calldata tokenIds) external nonReentrant returns (uint256) { /* Validate token IDs count */ if (tokenIds.length == 0 || tokenIds.length > MAX_BUNDLE_SIZE) revert InvalidSize(); /* Create encodedBundle */ bytes memory encodedBundle = abi.encodePacked(token); /* For each ERC-721 asset, add to encoded bundle and transfer to this contract */ for (uint256 i; i < tokenIds.length; i++) { encodedBundle = abi.encodePacked(encodedBundle, tokenIds[i]); IERC721(token).transferFrom(msg.sender, address(this), tokenIds[i]); } /* Hash encodedBundle */ uint256 tokenId = uint256(_hash(encodedBundle)); /* Mint BundleCollateralWrapper token */ _mint(msg.sender, tokenId); emit BundleMinted(tokenId, msg.sender, encodedBundle); return tokenId; } /** * Emits a {BundleUnwrapped} event * * @inheritdoc ICollateralWrapper */ function unwrap(uint256 tokenId, bytes calldata context) external nonReentrant { if (tokenId != uint256(_hash(context))) revert InvalidContext(); if (msg.sender != ownerOf(tokenId)) revert InvalidCaller(); /* Get token address from context */ address token = address(uint160(bytes20(context[0:20]))); /* Compute number of token ids */ uint256 tokenCount = (context.length - 20) / 32; _burn(tokenId); /* Transfer assets back to owner of token */ uint256 offset = 20; for (uint256 i; i < tokenCount; i++) { IERC721(token).transferFrom(address(this), msg.sender, uint256(bytes32(context[offset:offset + 32]))); offset += 32; } emit BundleUnwrapped(tokenId, msg.sender); } /******************************************************/ /* ERC165 interface */ /******************************************************/ /** * @inheritdoc IERC165 */ function supportsInterface(bytes4 interfaceId) public view override returns (bool) { return interfaceId == type(ICollateralWrapper).interfaceId || super.supportsInterface(interfaceId); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.20; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol"; import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "../interfaces/ICollateralWrapper.sol"; /** * @title ERC1155 Collateral Wrapper * @author MetaStreet Labs */ contract ERC1155CollateralWrapper is ICollateralWrapper, ERC721, ERC1155Holder, ReentrancyGuard { /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Implementation version */ string public constant IMPLEMENTATION_VERSION = "1.1"; /** * @notice Maximum token IDs */ uint256 internal constant MAX_TOKEN_IDS = 32; /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid caller */ error InvalidCaller(); /** * @notice Invalid context */ error InvalidContext(); /** * @notice Invalid token IDs size */ error InvalidSize(); /** * @notice Invalid token id */ error InvalidOrdering(); /**************************************************************************/ /* State */ /**************************************************************************/ /** * @notice Encoding nonce */ uint256 private _nonce; /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when batch is minted * @param tokenId Token ID of the new collateral wrapper token * @param account Address that created the batch * @param encodedBatch Encoded batch data */ event BatchMinted(uint256 indexed tokenId, address indexed account, bytes encodedBatch); /** * @notice Emitted when batch is unwrapped * @param tokenId Token ID of the batch collateral wrapper token * @param account Address that unwrapped the batch */ event BatchUnwrapped(uint256 indexed tokenId, address indexed account); /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice BatchCollateralWrapper constructor */ constructor() ERC721("MetaStreet ERC1155 Collateral Wrapper", "MSMTCW") {} /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc ICollateralWrapper */ function name() public pure override(ERC721, ICollateralWrapper) returns (string memory) { return "MetaStreet ERC1155 Collateral Wrapper"; } /** * @inheritdoc ERC721 */ function symbol() public pure override returns (string memory) { return "MSMTCW"; } /** * @notice Check if token ID exists * @param tokenId Token ID * @return True if token ID exists, otherwise false */ function exists(uint256 tokenId) external view returns (bool) { return _exists(tokenId); } /** * @inheritdoc ICollateralWrapper */ function enumerate(uint256 tokenId, bytes calldata context) external view returns (address, uint256[] memory) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Decode context */ (address token, , , uint256[] memory tokenIds, ) = abi.decode( context, (address, uint256, uint256, uint256[], uint256[]) ); return (token, tokenIds); } /** * @inheritdoc ICollateralWrapper */ function enumerateWithQuantities( uint256 tokenId, bytes calldata context ) external view returns (address, uint256[] memory, uint256[] memory) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Decode context */ (address token, , , uint256[] memory tokenIds, uint256[] memory quantities) = abi.decode( context, (address, uint256, uint256, uint256[], uint256[]) ); return (token, tokenIds, quantities); } /** * @inheritdoc ICollateralWrapper */ function count(uint256 tokenId, bytes calldata context) external view returns (uint256) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Decode context */ (, , uint256 count_, , ) = abi.decode(context, (address, uint256, uint256, uint256[], uint256[])); return count_; } /** * @inheritdoc ICollateralWrapper */ function transferCalldata( address token, address from, address to, uint256 tokenId, uint256 quantity ) external pure returns (address, bytes memory) { return (token, abi.encodeWithSelector(IERC1155.safeTransferFrom.selector, from, to, tokenId, quantity, "")); } /**************************************************************************/ /* Internal Helpers */ /**************************************************************************/ /** * @dev Compute hash of encoded batch * @param encodedBatch Encoded batch * @return batchTokenId Hash */ function _hash(bytes memory encodedBatch) internal view returns (bytes32) { /* Take hash of chain ID (32 bytes) concatenated with encoded batch */ return keccak256(abi.encodePacked(block.chainid, encodedBatch)); } /**************************************************************************/ /* User API */ /**************************************************************************/ /** * @notice Deposit a ERC1155 collateral into contract and mint a ERC1155CollateralWrapper token * * Emits a {BatchMinted} event * * @dev Collateral token, nonce, token ids, batch size, and quantities are encoded, * hashed and stored as the ERC1155CollateralWrapper token ID. * @param token Collateral token address * @param tokenIds List of token ids * @param quantities List of quantities */ function mint( address token, uint256[] calldata tokenIds, uint256[] calldata quantities ) external nonReentrant returns (uint256) { /* Validate token IDs and quantities */ if (tokenIds.length == 0 || tokenIds.length > MAX_TOKEN_IDS || tokenIds.length != quantities.length) revert InvalidSize(); /* Validate token ID and quantity */ uint256 batchSize; for (uint256 i; i < tokenIds.length; i++) { /* Validate unique token ID */ if (i != 0 && tokenIds[i] <= tokenIds[i - 1]) revert InvalidOrdering(); /* Validate quantity is non-zero */ if (quantities[i] == 0) revert InvalidSize(); /* Compute batch size */ batchSize += quantities[i]; } /* Create encoded batch and increment nonce */ bytes memory encodedBatch = abi.encode(token, _nonce++, batchSize, tokenIds, quantities); /* Hash encoded batch */ uint256 tokenId = uint256(_hash(encodedBatch)); /* Batch transfer tokens */ IERC1155(token).safeBatchTransferFrom(msg.sender, address(this), tokenIds, quantities, ""); /* Mint ERC1155CollateralWrapper token */ _mint(msg.sender, tokenId); emit BatchMinted(tokenId, msg.sender, encodedBatch); return tokenId; } /** * Emits a {BatchUnwrapped} event * * @inheritdoc ICollateralWrapper */ function unwrap(uint256 tokenId, bytes calldata context) external nonReentrant { if (tokenId != uint256(_hash(context))) revert InvalidContext(); if (msg.sender != ownerOf(tokenId)) revert InvalidCaller(); /* Decode context */ (address token, , , uint256[] memory tokenIds, uint256[] memory quantities) = abi.decode( context, (address, uint256, uint256, uint256[], uint256[]) ); /* Burn ERC1155CollateralWrapper token */ _burn(tokenId); /* Batch transfer tokens back to token owner */ IERC1155(token).safeBatchTransferFrom(address(this), msg.sender, tokenIds, quantities, ""); emit BatchUnwrapped(tokenId, msg.sender); } /******************************************************/ /* ERC165 interface */ /******************************************************/ /** * @inheritdoc IERC165 */ function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC1155Receiver) returns (bool) { return interfaceId == type(ICollateralWrapper).interfaceId || super.supportsInterface(interfaceId); } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity 0.8.20; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "../interfaces/ICollateralWrapper.sol"; import {ICryptoPunksMarket} from "../integrations/CryptoPunks/ICryptoPunksMarket.sol"; /** * @title Punk Collateral Wrapper * @author MetaStreet Labs */ contract PunkCollateralWrapper is ICollateralWrapper, ERC721, ReentrancyGuard { /**************************************************************************/ /* Constants */ /**************************************************************************/ /** * @notice Implementation version */ string public constant IMPLEMENTATION_VERSION = "1.0"; /** * @notice Maximum bundle size */ uint256 internal constant MAX_BUNDLE_SIZE = 32; /**************************************************************************/ /* Errors */ /**************************************************************************/ /** * @notice Invalid caller */ error InvalidCaller(); /** * @notice Invalid context */ error InvalidContext(); /** * @notice Invalid bundle size */ error InvalidSize(); /**************************************************************************/ /* Events */ /**************************************************************************/ /** * @notice Emitted when punk collateral wrapper is minted * @param tokenId Token ID of the new collateral wrapper token * @param account Address that created the punk collateral wrapper * @param encodedBundle Encoded bundle data */ event PunkMinted(uint256 indexed tokenId, address indexed account, bytes encodedBundle); /** * @notice Emitted when punk collateral wrapper is unwrapped * @param tokenId Token ID of the punk collateral wrapper token * @param account Address that unwrapped the punk collateral wrapper */ event PunkUnwrapped(uint256 indexed tokenId, address indexed account); /**************************************************************************/ /* Immutable State */ /**************************************************************************/ /** * @notice Crypto Punks Market */ ICryptoPunksMarket internal immutable _punksMarket; /** * @notice Crypto Punks Token (returned by enumerate API) */ address internal immutable _punksToken; /**************************************************************************/ /* Constructor */ /**************************************************************************/ /** * @notice PunkCollateralWrapper constructor * @param punksMarket Native Crypto Punks token address * @param punksToken Crypto Punks token address returned by enumerate API * * @dev This collateral wrapper is deployed with punksToken set to WPUNKS, * which is returned by the enumerate API, for backwards compatibility with * existing Crypto Punks pools. Frontends may need special handling for * dealing with the underlying native Crypto Punks tokens. */ constructor(address punksMarket, address punksToken) ERC721("MetaStreet Punk Collateral Wrapper", "MSPCW") { _punksMarket = ICryptoPunksMarket(punksMarket); _punksToken = punksToken; } /**************************************************************************/ /* Implementation */ /**************************************************************************/ /** * @inheritdoc ICollateralWrapper */ function name() public pure override(ERC721, ICollateralWrapper) returns (string memory) { return "MetaStreet Punk Collateral Wrapper"; } /** * @inheritdoc ERC721 */ function symbol() public pure override returns (string memory) { return "MSPCW"; } /** * @notice Check if token ID exists * @param tokenId Token ID * @return True if token ID exists, otherwise false */ function exists(uint256 tokenId) external view returns (bool) { return _exists(tokenId); } /** * @inheritdoc ICollateralWrapper */ function enumerate( uint256 tokenId, bytes calldata context ) external view returns (address token, uint256[] memory tokenIds) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Set punks token */ token = _punksToken; /* Compute number of tokens in context */ uint256 count_ = context.length / 32; /* Instantiate asset info array */ tokenIds = new uint256[](count_); /* Populate asset info array */ uint256 offset; for (uint256 i; i < count_; i++) { tokenIds[i] = uint256(bytes32(context[offset:offset + 32])); offset += 32; } } /** * @inheritdoc ICollateralWrapper */ function enumerateWithQuantities( uint256 tokenId, bytes calldata context ) external view returns (address token, uint256[] memory tokenIds, uint256[] memory quantities) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Set punks token */ token = _punksToken; /* Compute number of tokens in context */ uint256 count_ = context.length / 32; /* Instantiate asset info array */ tokenIds = new uint256[](count_); /* Instantiate quantities array */ quantities = new uint256[](count_); /* Populate arrays */ uint256 offset; for (uint256 i; i < count_; i++) { tokenIds[i] = uint256(bytes32(context[offset:offset + 32])); quantities[i] = 1; offset += 32; } } /** * @inheritdoc ICollateralWrapper */ function count(uint256 tokenId, bytes calldata context) external view returns (uint256) { if (tokenId != uint256(_hash(context))) revert InvalidContext(); /* Compute number of tokens in context */ return context.length / 32; } /** * @inheritdoc ICollateralWrapper */ function transferCalldata( address, address, address to, uint256 tokenId, uint256 ) external view returns (address, bytes memory) { return (address(_punksMarket), abi.encodeWithSelector(_punksMarket.transferPunk.selector, to, tokenId)); } /**************************************************************************/ /* Internal Helpers */ /**************************************************************************/ /** * @dev Compute hash of encoded bundle * @param encodedBundle Encoded bundle * @return Hash of encoded bundle */ function _hash(bytes memory encodedBundle) internal view returns (bytes32) { /* Take hash of chain ID (32 bytes) concatenated with encoded bundle */ return keccak256(abi.encodePacked(block.chainid, encodedBundle)); } /**************************************************************************/ /* User API */ /**************************************************************************/ /** * @notice Deposit Punk NFT collateral into contract and mint a PunkCollateralWrapper token * * Emits a {PunkMinted} event * * @dev Token ids are encoded, hashed and stored as * the PunkCollateralWrapper token ID. * @param tokenIds Punk token IDs */ function mint(uint256[] memory tokenIds) external nonReentrant returns (uint256) { /* Validate token IDs count */ if (tokenIds.length == 0 || tokenIds.length > MAX_BUNDLE_SIZE) revert InvalidSize(); /* Create encoded bundle */ bytes memory encodedBundle; /* For each punk, add to encoded bundle and transfer to this contract */ for (uint256 i; i < tokenIds.length; i++) { encodedBundle = abi.encodePacked(encodedBundle, tokenIds[i]); /* Validate that caller owns the punk */ if (_punksMarket.punkIndexToAddress(tokenIds[i]) != msg.sender) revert InvalidCaller(); /* Requires offerPunkForSaleToAddress with 0 ethers to this contract */ _punksMarket.buyPunk(tokenIds[i]); } /* Hash encodedBundle */ uint256 tokenId = uint256(_hash(encodedBundle)); /* Mint PunkCollateralWrapper token */ _mint(msg.sender, tokenId); emit PunkMinted(tokenId, msg.sender, encodedBundle); return tokenId; } /** * Emits a {PunkUnwrapped} event * * @inheritdoc ICollateralWrapper */ function unwrap(uint256 tokenId, bytes calldata context) external nonReentrant { if (tokenId != uint256(_hash(context))) revert InvalidContext(); if (msg.sender != ownerOf(tokenId)) revert InvalidCaller(); /* Compute number of token ids */ uint256 count_ = context.length / 32; _burn(tokenId); /* Transfer punk back to owner of token */ uint256 offset; for (uint256 i; i < count_; i++) { _punksMarket.transferPunk(msg.sender, uint256(bytes32(context[offset:offset + 32]))); offset += 32; } /* Emits PunkUnwrapped */ emit PunkUnwrapped(tokenId, msg.sender); } /******************************************************/ /* ERC165 interface */ /******************************************************/ /** * @inheritdoc IERC165 */ function supportsInterface(bytes4 interfaceId) public view override returns (bool) { return interfaceId == type(ICollateralWrapper).interfaceId || super.supportsInterface(interfaceId); } }
{ "viaIR": true, "optimizer": { "enabled": true, "runs": 800 }, "evmVersion": "shanghai", "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"name":"InactiveLiquidity","type":"error"},{"inputs":[],"name":"InsufficientShares","type":"error"},{"inputs":[],"name":"InsufficientTickSpacing","type":"error"},{"inputs":[],"name":"InvalidRedemptionStatus","type":"error"},{"inputs":[],"name":"InvalidTick","type":"error"}]
Contract Creation Code
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
Deployed Bytecode
0x6080604090808252307f000000000000000000000000ab4df303e49deda51e2d7be92a2ff5a30c10f0e114906004918236101561003a575f80fd5b5f91823560e01c908163284a2713146104c5575080633d05845e1461047d57806384c2dd4514610387578063bb6bcd0c146101d25763e44375ae1461007d575f80fd5b6101cf5761008a3661086a565b6006839492930133835280602052868320906001600160801b0395868616928386526020528660018a87200194169384865260205288852095865490888216998a156101c15750906100ef899260018a01948c858754169260058660801c93016109e3565b94928d84829d949d169e8f145f1461013c575050505050505050338452602052868320908352602052600186832001908252602052600185822082815501555b8351928352166020820152f35b610194969a508498506101749492939599509061015b919b979b6108e6565b166001600160801b03198098161780845560801c61089f565b81546001600160801b031660809190911b6001600160801b031916179055565b84549382851680848316105f146101ba576101af92506108e6565b16911617905561012f565b50506101af565b8b51638336ad7d60e01b8152fd5b80fd5b50929092610383576101e33661086a565b9094338152602095600684018752848220916001600160801b0380921692838252885285812094855460801c9761023c61021c8a6108ce565b88546001600160801b031660809190911b6001600160801b031916178855565b888352600187018a52878320918487169081158015610377575b61036757918b91600589969594019785528783528a80862060038101998a54978860801c958b808b169b61028a908d61089f565b169c6001600160801b03199d8e809c161790558301968682528781528b878180888620541614159b6102f59a6102ce9860019e610318575b50505050505050610f32565b83546001600160801b03908916919091171660809190911b6001600160801b031916178255565b01908382541617905561030c8454938285166108e6565b16911617905551908152f35b61035a968592610326610efe565b9784895280890196838852835252209451169084541617835551166001600160801b0382549181199060801b169116179055565b8f808f878e5f8f936102c2565b8951633999656760e01b81528390fd5b50858954168211610256565b8280fd5b509290926103835760a0366003190112610383576103a3610847565b906044359073ffffffffffffffffffffffffffffffffffffffff808316809303610479576103cf610831565b90608435946001600160801b039687871692838803610475576006823501921690818a5260209383855289878c20961695868c52855289878c20541610610467575088528082528388208389528252838820948554958861043289828a166108e6565b166001600160801b0319809816179055885281528287209187525284209261045e84549382851661089f565b16911617905580f35b8551633999656760e01b8152fd5b8980fd5b8580fd5b83858460803660031901126101cf57506104b360609261049b610847565b6104a3610817565b906104ac610831565b92356108ff565b91929081519384526020840152820152f35b918591506103835760803660031901126103835783356024948535906001600160801b039283831691828403610813576104fd610817565b93610506610831565b976001840154905f19908183019283116108015760028601549182019182116108015761055a84906effffffffffffffffffffffffffffff8260081c169160078160051c1691600360078360021c16921690565b9592939093156107f35750116107e357116107d3576107c45760058301848a5280602052878a2091851580156107bb575b6107ab5761059a908383610cd2565b60058201958654968760c01c420342811161073957891667ffffffffffffffff8960801c1602898116908103610739576105d78a91828b1661089f565b16978877ffffffffffffffff000000000000000000000000000000007fffffffffffffffff0000000000000000000000000000000000000000000000004260c01b169216171790558254968760801c9081155f1461074b575050670de0b6b3a76400005b670de0b6b3a7640000828a1681810291811591830414171561073957899a9b9c9d506106a3898b61068a8661068161067c6106e39b9a99986106c3986109c5565b610c53565b9e8f941661089f565b166001600160801b0319809c161780875560801c61089f565b84546001600160801b031660809190911b6001600160801b031916178455565b6001830190888b6106d884549382851661089f565b169116179055610f32565b8585169786891591821561072d575b505061071f575096859160066020993384520189528282209082528852209261030c84549382851661089f565b8651633999656760e01b8152fd5b1689109050868b6106f2565b634e487b7160e01b8d52601186528d8dfd5b610757908a8a1661089f565b898061076d6001880154828160801c911661089f565b92169116808210156107a457505b670de0b6b3a764000090818102918183041490151715610739579061079f916109c5565b61063b565b905061077b565b885163de2c0fcf60e01b81528490fd5b5087861461058b565b5085516333a3bdff60e21b8152fd5b87516333a3bdff60e21b81528390fd5b89516333a3bdff60e21b81528590fd5b6333a3bdff60e21b81528790fd5b634e487b7160e01b8c52601185528c8cfd5b8780fd5b604435906001600160801b038216820361082d57565b5f80fd5b606435906001600160801b038216820361082d57565b6024359073ffffffffffffffffffffffffffffffffffffffff8216820361082d57565b606090600319011261082d57600435906001600160801b0390602435828116810361082d5791604435908116810361082d5790565b9190916001600160801b03808094169116019182116108ba57565b634e487b7160e01b5f52601160045260245ffd5b6001600160801b038091169081146108ba5760010190565b6001600160801b0391821690821603919082116108ba57565b93919373ffffffffffffffffffffffffffffffffffffffff5f921682526006810160205260408220936001600160801b03948587168452602052846001604085200191168352602052604082208054958587169182156109a057600101548616968694938593610977938a9360801c926005016109e3565b9392979190501695169583821681115f1461099a5761099692506108e6565b1690565b50501690565b505050509150915080918190565b90612af8918281029281840414901517156108ba57565b81156109cf570490565b634e487b7160e01b5f52601260045260245ffd5b9293949190945f935f935f916001600160801b035f99165f5260205260405f20906001600160801b038816609681018091116108ba5797906003830154915b6001600160801b03610a34888861089f565b166001600160801b038c161080610b89575b15610b7c576001600160801b0381168360801c8114610b6e575f526004840160205260405f20946001600160801b03600181831601116108ba5760016001600160801b03610aa392160195549b6001600160801b038d169061089f565b9a6001600160801b03878116908d1611610ac65750610ac1906108ce565b610a22565b868a8d6001600160801b03610adf8c9d9e969d8561089f565b166001600160801b0382161115610b5c5750610afc9150896108e6565b998160801c91670de0b6b3a76400009083828102048214841517156108ba57610ac1946001600160801b03610b498f610b43610b5698610b50978561067c981691026109c5565b9361089f565b9e16610b9b565b9061089f565b976108ce565b610afc92610b69916108e6565b6108e6565b505094505050939592945050565b5094505050939592945050565b50896001600160801b03821610610a46565b905f1981830981830291828083109203918083039214610c4257670de0b6b3a76400009082821115610bfd577faccb18165bd6fe31ae1cf318dc5b51eee0e1ba569b88cd74c1773b91fac10669940990828211900360ee1b910360121c170290565b60405162461bcd60e51b815260206004820152601560248201527f4d6174683a206d756c446976206f766572666c6f7700000000000000000000006044820152606490fd5b5050670de0b6b3a764000091500490565b6001600160801b0390818111610c67571690565b60405162461bcd60e51b815260206004820152602760248201527f53616665436173743a2076616c756520646f65736e27742066697420696e203160448201527f32382062697473000000000000000000000000000000000000000000000000006064820152608490fd5b9190610cdd81610ed9565b610eb757610cea81610ebc565b15610ea5575f938480526020928484526040958681205b600281015460801c916001600160801b038416831015610d2b575050805f52858552865f20610d01565b92959396915093610d6383906effffffffffffffffffffffffffffff8260081c169160078160051c1691600360078360021c16921690565b505050946002610d9a88906effffffffffffffffffffffffffffff8260081c169160078160051c1691600360078360021c16921690565b505050910195610dd5875460801c906effffffffffffffffffffffffffffff8260081c169160078160051c1691600360078360021c16921690565b50505090808314159081610e8e575b50610e7d57808214159182610e65575b5050610e5457600290810180546001600160801b03199081166001600160801b03958616908117835587548216179091558554608090811c5f9081529390955297909120018054871685831617905582541692901b90931617909155565b565b87516351f259c760e11b8152600490fd5b612710919250610e74906109ae565b04115f80610df4565b89516351f259c760e11b8152600490fd5b6127109150610e9c906109ae565b0482105f610de4565b60405163de2c0fcf60e01b8152600490fd5b505050565b805460801c159081610ecc575090565b60019150015460801c1590565b600201546001600160801b0381161590811591610ef4575090565b905060801c151590565b604051906040820182811067ffffffffffffffff821117610f1e57604052565b634e487b7160e01b5f52604160045260245ffd5b60038201918254906001600160801b03918281169384156111ac57825494670de0b6b3a764000090858716828102908015908204841417156108ba57610f7d90608098891c906109c5565b918261106157505050505060018101918254841c61105a576110276110479186549561101e82881692610fae610efe565b9084825260208201995f8b52841c610fe8610fc8826108ce565b8d546001600160801b031660809190911b6001600160801b031916178d55565b5f9081526004890160205260409020915199516001600160801b031990821660801b811691909a166001600160801b0316179055565b8454901c6108e6565b82546001600160801b031660809190911b6001600160801b031916178255565b8281541690558181541690558154169055565b5050505050565b600186989395999697949701918483541691821561119f57808302928304036108ba578461067c91611096886110a9956109c5565b908082101561119857505b169586610b9b565b841561118d5761114861112886869561111f610e529d60048e8d6110e96110ce610efe565b94888652602086019e8f908d169052871c91610174836108ce565b5f908152910160205260409020905199516001600160801b0319908a1660801b81169a8a166001600160801b03169a909a179055565b8b54901c6108e6565b89546001600160801b031660809190911b6001600160801b031916178955565b87548484611158848285166108e6565b169116178855838361116e8454938285166108e6565b1691161790556111828454938285166108e6565b1691161790556111b4565b505050505050505050565b90506110a1565b5050505050505050505050565b505050505050565b81548060801c801580159283611262575b5050501580611252575b8015611242575b61123e5760025f92019061121a82546001600160801b0392838216865260205260801c60026040862001906001600160801b0382549181199060801b169116179055565b8154908160801c84526002604085200191166001600160801b031982541617905555565b5050565b5061124c82610ed9565b156111d6565b5061125c82610ebc565b156111cf565b6001600160801b03919293501690670de0b6b3a7640000918281029281840414901517156108ba5766b1a2bc2ec500008084029384041417156108ba57105f80806111c556fea264697066735822122082043a19331cf39292ea1f9699250e53b0310ef6cfec31566ad60a2e18205d8464736f6c63430008140033
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
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.