Contract Name:
DraggableShares
Contract Source Code:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @title Standard ERC20 Errors
/// @dev See https://eips.ethereum.org/EIPS/eip-20
/// https://eips.ethereum.org/EIPS/eip-6093
interface ERC20Errors {
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
error ERC20InvalidSender(address sender);
error ERC20InvalidReceiver(address receiver);
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
error ERC20InvalidApprover(address approver);
error ERC20InvalidSpender(address spender);
}
// SPDX-License-Identifier: MIT
// Copied and adjusted from OpenZeppelin
// Adjustments:
// - modifications to support ERC-677
// - removed unnecessary require statements
// - removed GSN Context
// - upgraded to 0.8 to drop SafeMath
// - let name() and symbol() be implemented by subclass
// - infinite allowance support, with 2^255 and above considered infinite
// - use upper 32 bits of balance for flags
// - add a global settings variable
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./ERC20Errors.sol";
import "./IERC677Receiver.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 `ERC20Mintable`.
*
* *For a detailed writeup see our guide [How to implement supply
* mechanisms](https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226).*
*
* We have followed general OpenZeppelin guidelines: functions revert instead
* of 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`.
*/
abstract contract ERC20Flaggable is IERC20, ERC20Errors {
// as Documented in /doc/infiniteallowance.md
// 0x8000000000000000000000000000000000000000000000000000000000000000
uint256 constant private INFINITE_ALLOWANCE = 2**255;
uint256 private constant FLAGGING_MASK = 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000;
// Documentation of flags used by subclasses:
// NOTE: flags denote the bit number that is being used and must be smaller than 32
// ERC20Draggable: uint8 private constant FLAG_INDEX_VOTED = 1;
// ERC20Recoverable: uint8 private constant FLAG_INDEX_CLAIM_PRESENT = 10;
// ERCAllowlistable: uint8 private constant FLAG_INDEX_ALLOWLIST = 20;
// ERCAllowlistable: uint8 private constant FLAG_INDEX_FORBIDDEN = 21;
// ERCAllowlistable: uint8 private constant FLAG_INDEX_POWERLIST = 22;
mapping (address => uint256) private _balances; // upper 32 bits reserved for flags
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public override decimals;
event NameChanged(string name, string symbol);
/// Overflow on minting, transfer.
/// @param receiver The address were the balance overflows.
/// @param balance The current balance of the receiver.
/// @param amount The amount added, which result in the overflow.
error ERC20BalanceOverflow(address receiver, uint256 balance, uint256 amount);
constructor(uint8 _decimals) {
decimals = _decimals;
}
/**
* @dev See `IERC20.totalSupply`.
*/
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
/**
* @dev See `IERC20.balanceOf`.
*/
function balanceOf(address account) public view override returns (uint256) {
return uint224 (_balances [account]);
}
function hasFlag(address account, uint8 number) external view returns (bool) {
return hasFlagInternal(account, number);
}
function setFlag(address account, uint8 index, bool value) internal {
uint256 flagMask = 1 << (index + 224);
uint256 balance = _balances [account];
if ((balance & flagMask == flagMask) != value) {
_balances [account] = balance ^ flagMask;
}
}
function hasFlagInternal(address account, uint8 number) internal view returns (bool) {
uint256 flag = 0x1 << (number + 224);
return _balances[account] & flag == flag;
}
/**
* @dev See `IERC20.transfer`.
*
* Requirements:
*
* - `recipient` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, 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`.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) external override returns (bool) {
_approve(msg.sender, spender, value);
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`;
*
* Requirements:
* - `sender` and `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `value`.
* - the caller must have allowance for `sender`'s tokens of at least
* `amount`.
*/
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = allowance(sender, msg.sender);
if (currentAllowance < INFINITE_ALLOWANCE){
// Only decrease the allowance if it was not set to 'infinite'
// Documented in /doc/infiniteallowance.md
_allowances[sender][msg.sender] = currentAllowance - amount;
}
return true;
}
/**
* @dev Moves tokens `amount` from `sender` to `recipient`.
*
* This is 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:
*
* - `sender` cannot be the zero address.
* - `recipient` cannot be the zero address.
* - `sender` must have a balance of at least `amount`.
*/
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
_beforeTokenTransfer(sender, recipient, amount);
decreaseBalance(sender, amount);
increaseBalance(recipient, amount);
emit Transfer(sender, recipient, amount);
}
// ERC-677 functionality, can be useful for swapping and wrapping tokens
function transferAndCall(address recipient, uint amount, bytes calldata data) external virtual returns (bool) {
return transfer (recipient, amount)
&& IERC677Receiver (recipient).onTokenTransfer (msg.sender, amount, data);
}
/** @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
*
* - `to` cannot be the zero address.
*/
function _mint(address recipient, uint256 amount) internal virtual {
_beforeTokenTransfer(address(0), recipient, amount);
_totalSupply += amount;
increaseBalance(recipient, amount);
emit Transfer(address(0), recipient, amount);
}
function increaseBalance(address recipient, uint256 amount) private {
if (recipient == address(0x0)) {
revert ERC20InvalidReceiver(recipient); //use burn instead
}
uint256 oldBalance = _balances[recipient];
uint256 newBalance = oldBalance + amount;
if (oldBalance & FLAGGING_MASK != newBalance & FLAGGING_MASK) {
revert ERC20BalanceOverflow(recipient, oldBalance, amount);
}
_balances[recipient] = newBalance;
}
/**
* @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 {
_beforeTokenTransfer(account, address(0), amount);
_totalSupply -= amount;
decreaseBalance(account, amount);
emit Transfer(account, address(0), amount);
}
function decreaseBalance(address sender, uint256 amount) private {
uint256 oldBalance = _balances[sender];
uint256 newBalance = oldBalance - amount;
if (oldBalance & FLAGGING_MASK != newBalance & FLAGGING_MASK) {
revert ERC20InsufficientBalance(sender, balanceOf(sender), amount);
}
_balances[sender] = newBalance;
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
*
* This is 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 value) internal {
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
/**
* @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 to 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].
*/
// solhint-disable-next-line no-empty-blocks
function _beforeTokenTransfer(address from, address to, uint256 amount) virtual internal {
// intentionally left blank
}
/**
* Checks if msg.sender is an authorized address.
* @param validSender The authorized address.
*/
function _checkSender(address validSender) internal view {
if (msg.sender != validSender) {
revert ERC20InvalidSender(msg.sender);
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import "./ERC20Flaggable.sol";
import "../utils/Permit2Hub.sol";
/// @title ERC20Permit2
/// @dev This abstract contract extends the ERC20Flaggable contract and introduces the Permit2Hub.
abstract contract ERC20Permit2 is ERC20Flaggable {
/// @dev The Permit2Hub contract instance.
Permit2Hub public immutable permit2Hub;
/// @dev Initializes the ERC20Permit2 contract.
/// @param _permit2Hub The address of the Permit2Hub contract.
constructor(Permit2Hub _permit2Hub) {
permit2Hub = _permit2Hub;
}
/// @inheritdoc ERC20Flaggable
function allowance(address owner, address spender) public view virtual override(ERC20Flaggable) returns (uint256) {
if (permit2Hub.isPermit2Enabled(owner, spender))
return type(uint256).max; // If permit is enabled, return the maximum value of uint256
else
return super.allowance(owner, spender); // Otherwise, call the parent(ERC20Flaggable) allowance function
}
}
// SPDX-License-Identifier: MIT
// Copied from https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol
// and modified it.
pragma solidity ^0.8.0;
import "./ERC20Flaggable.sol";
import "./IERC20Permit.sol";
abstract contract ERC20PermitLight is ERC20Flaggable, IERC20Permit {
/*//////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
mapping(address => uint256) public override nonces;
/*//////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public override {
if (deadline < block.timestamp) {
revert Permit_DeadlineExpired(deadline, block.timestamp);
}
unchecked { // unchecked to save a little gas with the nonce increment...
address recoveredAddress = ecrecover(
keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(
abi.encode(
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"),
bytes32(0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9),
owner,
spender,
value,
nonces[owner]++,
deadline
)
)
)
),
v,
r,
s
);
if (recoveredAddress == address(0) || recoveredAddress != owner) {
revert Permit_InvalidSigner(recoveredAddress);
}
_approve(recoveredAddress, spender, value);
}
}
function DOMAIN_SEPARATOR() public view override returns (bytes32) {
return
keccak256(
abi.encode(
//keccak256("EIP712Domain(uint256 chainId,address verifyingContract)");
bytes32(0x47e79534a245952e8b16893a336b85a3d9ea9fa8c573f3d803afb92a79469218),
block.chainid,
address(this)
)
);
}
}
/**
* SPDX-License-Identifier: MIT
*
* Copyright (c) 2016-2019 zOS Global Limited
*
*/
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see `ERC20Detailed`.
*/
interface IERC20 {
// Optional functions
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
/**
* @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 `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a `Transfer` event.
*/
function transfer(address recipient, 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.
*
* > 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount) external returns (bool);
/**
* @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);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
// Copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/draft-IERC20Permit.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
/**
* @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 is IERC20 {
/*//////////////////////////////////////////////////////////////
Custom errors
//////////////////////////////////////////////////////////////*/
/// Block timestamp must to be before deadline.
/// @param deadline The deadline of the permit.
/// @param blockTimestamp The timestamp of the execution block.
error Permit_DeadlineExpired(uint256 deadline, uint256 blockTimestamp);
/// Recovered address must be owner and not zero address.
/// @param signerAddress The recovered signer address.
error Permit_InvalidSigner(address signerAddress);
/**
* @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
pragma solidity ^0.8.0;
// Given that development on ERC 677 has stalled, we should consider supporting EIP 1363: https://eips.ethereum.org/EIPS/eip-1363
interface IERC677Receiver {
error IERC677_OnTokenTransferFailed();
function onTokenTransfer(address from, uint256 amount, bytes calldata data) external returns (bool);
}
/**
* SPDX-License-Identifier: LicenseRef-Aktionariat
*
* MIT License with Automated License Fee Payments
*
* Copyright (c) 2022 Aktionariat AG (aktionariat.com)
*
* Permission is hereby granted to any person obtaining a copy of this software
* and associated documentation files (the "Software"), to deal in the Software
* without restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies of the
* Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* - The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* - All automated license fee payments integrated into this and related Software
* are preserved.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
pragma solidity ^0.8.0;
/**
* @title ERC-20 tokens subject to a drag-along agreement
* @author Luzius Meisser, [email protected]
*
* This is an ERC-20 token that is bound to a shareholder or other agreement that contains
* a drag-along clause. The smart contract can help enforce this drag-along clause in case
* an acquirer makes an offer using the provided functionality. If a large enough quorum of
* token holders agree, the remaining token holders can be automatically "dragged along" or
* squeezed out. For shares non-tokenized shares, the contract relies on an external Oracle
* to provide the votes of those.
*
* Subclasses should provide a link to a human-readable form of the agreement.
*/
import "./IDraggable.sol";
import "../ERC20/ERC20Flaggable.sol";
import "../ERC20/IERC20.sol";
import "../ERC20/IERC677Receiver.sol";
import "./IOffer.sol";
import "./IOfferFactory.sol";
import "../shares/IShares.sol";
import "../utils/SafeERC20.sol";
abstract contract ERC20Draggable is IERC677Receiver, IDraggable, ERC20Flaggable {
using SafeERC20 for IERC20;
// If flag is not present, one can be sure that the address did not vote. If the
// flag is present, the address might have voted and one needs to check with the
// current offer (if any) when transferring tokens.
uint8 private constant FLAG_VOTE_HINT = 1;
IERC20 public override wrapped; // The wrapped contract
IOfferFactory public immutable factory;
// If the wrapped tokens got replaced in an acquisition, unwrapping might yield many currency tokens
uint256 public unwrapConversionFactor = 0;
// The current acquisition attempt, if any. See initiateAcquisition to see the requirements to make a public offer.
IOffer public override offer;
uint256 private constant QUORUM_MULTIPLIER = 10000;
uint256 public immutable quorumMigration; // used for contract migartion, in BPS (out of 10'000)
uint256 public immutable quorum; // used for drag-along at acquisition offers, in BPS (out of 10'000)
uint256 public immutable votePeriod; // In seconds
address public override oracle;
struct DraggableParams {
IERC20 wrappedToken;
uint256 quorumDrag;
uint256 quorumMigration;
uint256 votePeriod;
}
event MigrationSucceeded(address newContractAddress, uint256 yesVotes, uint256 oracleVotes, uint256 totalVotingPower);
event ChangeOracle(address oracle);
/**
* Note that the Brokerbot only supports tokens that revert on failure and where transfer never returns false.
*/
constructor(
DraggableParams memory _params,
IOfferFactory _offerFactory,
address _oracle
)
ERC20Flaggable(0)
{
wrapped = _params.wrappedToken;
quorum = _params.quorumDrag;
quorumMigration = _params.quorumMigration;
votePeriod = _params.votePeriod;
factory = _offerFactory;
oracle = _oracle;
}
modifier onlyOracle {
_checkSender(oracle);
_;
}
modifier onlyWrappedToken {
_checkSender(address(wrapped));
_;
}
modifier onlyOffer(){
_checkSender(address(offer));
_;
}
modifier checkBinding(bool expected) {
if (expected != isBinding()) {
if(expected) {
revert Draggable_NotBinding();
}
if(!expected) {
revert Draggable_IsBinding();
}
}
_;
}
function onTokenTransfer(
address from,
uint256 amount,
bytes calldata
) external override onlyWrappedToken returns (bool) {
_mint(from, amount);
return true;
}
/** Wraps additional tokens, thereby creating more ERC20Draggable tokens. */
function wrap(address shareholder, uint256 amount) external {
wrapped.safeTransferFrom(msg.sender, address(this), amount);
_mint(shareholder, amount);
}
/**
* Indicates that the token holders are bound to the token terms and that:
* - Conversion back to the wrapped token (unwrap) is not allowed
* - A drag-along can be performed by making an according offer
* - They can be migrated to a new version of this contract in accordance with the terms
*/
function isBinding() public view returns (bool) {
return unwrapConversionFactor == 0;
}
/**
* Current recommended naming convention is to add the postfix "SHA" to the plain shares
* in order to indicate that this token represents shares bound to a shareholder agreement.
*/
function name() public view override returns (string memory) {
string memory wrappedName = wrapped.name();
if (isBinding()) {
return string(abi.encodePacked(wrappedName, " SHA"));
} else {
return string(abi.encodePacked(wrappedName, " (Wrapped)"));
}
}
function symbol() public view override returns (string memory) {
// ticker should be less dynamic than name
return string(abi.encodePacked(wrapped.symbol(), "S"));
}
/**
* Deactivates the drag-along mechanism and enables the unwrap function.
*/
function _deactivate(uint256 factor) internal {
if (factor == 0) {
revert Draggable_FactorZero();
}
unwrapConversionFactor = factor;
}
/** Decrease the number of drag-along tokens. The user gets back their shares in return */
function unwrap(uint256 amount) external override checkBinding(false) {
_unwrap(msg.sender, amount, unwrapConversionFactor);
}
function _unwrap(address owner, uint256 amount, uint256 factor) internal {
_burn(owner, amount);
wrapped.safeTransfer(owner, amount * factor);
}
/**
* Burns both the token itself as well as the wrapped token!
* If you want to get out of the shareholder agreement, use unwrap after it has been
* deactivated by a majority vote or acquisition.
*
* Burning only works if wrapped token supports burning. Also, the exact meaning of this
* operation might depend on the circumstances. Burning and reussing the wrapped token
* does not free the sender from the legal obligations of the shareholder agreement.
*/
function burn(uint256 amount) external {
_burn(msg.sender, amount);
IShares(address(wrapped)).burn(isBinding() ? amount : amount * unwrapConversionFactor);
}
function makeAcquisitionOffer(
bytes32 salt,
uint256 pricePerShare,
IERC20 currency
) external payable checkBinding(true) {
IOffer newOffer = factory.create{value: msg.value}(
salt, msg.sender, pricePerShare, currency, quorum, votePeriod);
if (_offerExists()) {
offer.makeCompetingOffer(newOffer);
}
offer = newOffer;
}
function drag(address buyer, IERC20 currency) external override onlyOffer {
_unwrap(buyer, balanceOf(buyer), 1);
_replaceWrapped(currency, buyer);
}
function notifyOfferEnded() external override onlyOffer {
offer = IOffer(address(0));
}
function _replaceWrapped(IERC20 newWrapped, address oldWrappedDestination) internal checkBinding(true) {
// Free all old wrapped tokens we have
wrapped.safeTransfer(oldWrappedDestination, wrapped.balanceOf(address(this)));
// Count the new wrapped tokens
wrapped = newWrapped;
if (totalSupply() > 0) // if there are no tokens, no need to deactivate
_deactivate(newWrapped.balanceOf(address(this)) / totalSupply());
emit NameChanged(name(), symbol());
}
function setOracle(address newOracle) external override onlyOracle {
oracle = newOracle;
emit ChangeOracle(oracle);
}
function migrateWithExternalApproval(address successor, uint256 additionalVotes) external override onlyOracle {
// Additional votes cannot be higher than the votes not represented by these tokens.
// The assumption here is that more shareholders are bound to the shareholder agreement
// that this contract helps enforce and a vote among all parties is necessary to change
// it, with an oracle counting and reporting the votes of the others.
if (totalSupply() + additionalVotes > totalVotingTokens()) {
revert Draggable_TooManyVotes(totalVotingTokens(), totalSupply() + additionalVotes);
}
_migrate(successor, additionalVotes);
}
function migrate() external override {
_migrate(msg.sender, 0);
}
function _migrate(address successor, uint256 additionalVotes) internal {
uint256 yesVotes = additionalVotes + balanceOf(successor);
uint256 totalVotes = totalVotingTokens();
if (yesVotes > totalVotes) {
revert Draggable_TooManyVotes(totalVotes, yesVotes);
}
if (_offerExists()) {
// if you have the quorum, you can cancel the offer first if necessary
revert Draggable_OpenOffer();
}
if (yesVotes * QUORUM_MULTIPLIER < totalVotes * quorumMigration) {
revert Draggable_QuorumNotReached(totalVotes * quorumMigration, yesVotes * QUORUM_MULTIPLIER);
}
_replaceWrapped(IERC20(successor), successor);
emit MigrationSucceeded(successor, yesVotes, additionalVotes, totalVotes);
}
function votingPower(address voter) external view override returns (uint256) {
return balanceOf(voter);
}
function totalVotingTokens() public view override returns (uint256) {
return IShares(address(wrapped)).totalShares();
}
function _hasVoted(address voter) internal view returns (bool) {
return hasFlagInternal(voter, FLAG_VOTE_HINT);
}
function notifyVoted(address voter) external override onlyOffer {
setFlag(voter, FLAG_VOTE_HINT, true);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
if (_hasVoted(from) || _hasVoted(to)) {
if (_offerExists()) {
offer.notifyMoved(from, to, amount);
} else {
setFlag(from, FLAG_VOTE_HINT, false);
setFlag(to, FLAG_VOTE_HINT, false);
}
}
super._beforeTokenTransfer(from, to, amount);
}
function _offerExists() internal view returns (bool) {
return address(offer) != address(0) && ! offer.isKilled(); // needs to have contract deployed AND offer needs to be not in deleted state
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../ERC20/IERC20.sol";
import "./IOffer.sol";
interface IDraggable is IERC20 {
/*//////////////////////////////////////////////////////////////
Custom errors
//////////////////////////////////////////////////////////////*/
/// conversion factor has to be > 0 for this transaction.
error Draggable_NotBinding();
/// conversion factor has to be = 0 for this transaction.
error Draggable_IsBinding();
/// conversion factor can't be 0 if binding gets deactivated.
error Draggable_FactorZero();
/// the reported votes can't be > max voting tokens.
/// @param maxVotes The max voting tokens.
/// @param reportedVotes The actual reported votes.
error Draggable_TooManyVotes(uint256 maxVotes, uint256 reportedVotes);
/// there is still an open offer that has to be canceled first
error Draggable_OpenOffer();
/// For migration the quorum needs to be reached.
/// @param needed The needed quorum.
/// @param actual The current yes votes.
error Draggable_QuorumNotReached(uint256 needed, uint256 actual);
function wrapped() external view returns (IERC20);
function unwrap(uint256 amount) external;
function offer() external view returns (IOffer);
function oracle() external view returns (address);
function drag(address buyer, IERC20 currency) external;
function notifyOfferEnded() external;
function votingPower(address voter) external returns (uint256);
function totalVotingTokens() external view returns (uint256);
function notifyVoted(address voter) external;
function migrate() external;
function setOracle(address newOracle) external;
function migrateWithExternalApproval(address successor, uint256 additionalVotes) external;
function setTerms(string calldata _terms) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../ERC20/IERC20.sol";
interface IOffer {
/*//////////////////////////////////////////////////////////////
Custom errors
//////////////////////////////////////////////////////////////*/
/// Invalid msg.sender.
/// @param sender The msg.sender of the transaction.
error Offer_InvalidSender(address sender);
/// Offer needs to be still open.
error Offer_AlreadyAccepted();
/// Offer needs to be not accepted yet.
error Offer_NotAccepted();
/// Sender of the offer needs to have needed funds in his account.
error Offer_NotWellFunded();
/// New offer not valid. `newPrice` needs to be higher than `oldPrice`.
/// @param oldPrice Price of the old offer.
/// @param newPrice Price of the new offer.
error Offer_OldOfferBetter(uint256 oldPrice, uint256 newPrice);
/// Voting needs to be still open.
error Offer_VotingEnded();
/// Too many (External) reported votes. `reportedVotes` needs to be less or equal to `maxVotes`.
/// @param maxVotes The max possible votes for the token.
/// @param reportedVotes The external reported votes + circulating supply of the token.
error Offer_TooManyVotes(uint256 maxVotes, uint256 reportedVotes);
/// Competing offer needs to be in the same currency.
error Offer_OfferInWrongCurrency();
/// Offer got already killed.
error Offer_IsKilled();
/*//////////////////////////////////////////////////////////////
Function Interfaces
//////////////////////////////////////////////////////////////*/
function makeCompetingOffer(IOffer newOffer) external;
// if there is a token transfer while an offer is open, the votes get transfered too
function notifyMoved(address from, address to, uint256 value) external;
function currency() external view returns (IERC20);
function price() external view returns (uint256);
function isWellFunded() external view returns (bool);
function voteYes() external;
function voteNo() external;
function isKilled() external view returns (bool);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../ERC20/IERC20.sol";
import "./IOffer.sol";
interface IOfferFactory {
function create(
bytes32 salt, address buyer, uint256 pricePerShare, IERC20 currency, uint256 quorum, uint256 votePeriod
) external payable returns (IOffer);
}
/**
* SPDX-License-Identifier: LicenseRef-Aktionariat
*
* MIT License with Automated License Fee Payments
*
* Copyright (c) 2022 Aktionariat AG (aktionariat.com)
*
* Permission is hereby granted to any person obtaining a copy of this software
* and associated documentation files (the "Software"), to deal in the Software
* without restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies of the
* Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* - The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* - All automated license fee payments integrated into this and related Software
* are preserved.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
pragma solidity ^0.8.0;
import "../ERC20/ERC20Flaggable.sol";
import "./IRecoveryHub.sol";
import "./IRecoverable.sol";
/**
* @title Recoverable
* In case of tokens that represent real-world assets such as shares of a company, one needs a way
* to handle lost private keys. With physical certificates, courts can declare share certificates as
* invalid so the company can issue replacements. Here, we want a solution that does not depend on
* third parties to resolve such cases. Instead, when someone has lost a private key, he can use the
* declareLost function on the recovery hub to post a deposit and claim that the shares assigned to a
* specific address are lost.
* If an attacker trying to claim shares belonging to someone else, they risk losing the deposit
* as it can be claimed at anytime by the rightful owner.
* Furthermore, if "getClaimDeleter" is defined in the subclass, the returned address is allowed to
* delete claims, returning the collateral. This can help to prevent obvious cases of abuse of the claim
* function, e.g. cases of front-running.
* Most functionality is implemented in a shared RecoveryHub.
*/
abstract contract ERC20Recoverable is ERC20Flaggable, IRecoverable {
uint8 private constant FLAG_CLAIM_PRESENT = 10;
// ERC-20 token that can be used as collateral or 0x0 if disabled
IERC20 public customCollateralAddress;
// Rate the custom collateral currency is multiplied to be valued like one share.
uint256 public customCollateralRate;
uint256 constant CLAIM_PERIOD = 180 days;
IRecoveryHub public override immutable recovery;
constructor(IRecoveryHub recoveryHub){
recovery = recoveryHub;
}
modifier onlyRecovery {
_checkSender(address(recovery));
_;
}
/**
* Returns the collateral rate for the given collateral type and 0 if that type
* of collateral is not accepted. By default, only the token itself is accepted at
* a rate of 1:1.
*
* Subclasses should override this method if they want to add additional types of
* collateral.
*/
function getCollateralRate(IERC20 collateralType) public override virtual view returns (uint256) {
if (address(collateralType) == address(this)) {
return 1;
} else if (collateralType == customCollateralAddress) {
return customCollateralRate;
} else {
return 0;
}
}
function claimPeriod() external pure override returns (uint256){
return CLAIM_PERIOD;
}
/**
* Allows subclasses to set a custom collateral besides the token itself.
* The collateral must be an ERC-20 token that returns true on successful transfers and
* throws an exception or returns false on failure.
* Also, do not forget to multiply the rate in accordance with the number of decimals of the collateral.
* For example, rate should be 7*10**18 for 7 units of a collateral with 18 decimals.
*/
function _setCustomClaimCollateral(IERC20 collateral, uint256 rate) internal {
customCollateralAddress = collateral;
if (address(customCollateralAddress) == address(0)) {
customCollateralRate = 0; // disabled
} else {
if (rate == 0) {
revert Recoverable_RateZero();
}
customCollateralRate = rate;
}
}
function getClaimDeleter() virtual public view returns (address);
function transfer(address recipient, uint256 amount) override(ERC20Flaggable, IERC20) virtual public returns (bool) {
super.transfer(recipient, amount); // no need for safe transfer, as it's our own token
if (hasFlagInternal(msg.sender, FLAG_CLAIM_PRESENT)){
recovery.clearClaimFromToken(msg.sender);
}
return true;
}
function notifyClaimMade(address target) external override onlyRecovery {
setFlag(target, FLAG_CLAIM_PRESENT, true);
}
function notifyClaimDeleted(address target) external override onlyRecovery {
setFlag(target, FLAG_CLAIM_PRESENT, false);
}
function deleteClaim(address lostAddress) external {
_checkSender(getClaimDeleter());
recovery.deleteClaim(lostAddress);
}
function recover(address oldAddress, address newAddress) external override onlyRecovery {
_transfer(oldAddress, newAddress, balanceOf(oldAddress));
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../ERC20/IERC20.sol";
import "./IRecoveryHub.sol";
interface IRecoverable is IERC20{
/*//////////////////////////////////////////////////////////////
Custom errors
//////////////////////////////////////////////////////////////*/
/// The new custom claim collateral rate has to be always > 0.
error Recoverable_RateZero();
// returns the recovery hub
function recovery() external view returns (IRecoveryHub);
function claimPeriod() external view returns (uint256);
function notifyClaimMade(address target) external;
function notifyClaimDeleted(address target) external;
function getCollateralRate(IERC20 collateral) external view returns(uint256);
function recover(address oldAddress, address newAddress) external;
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IRecoverable.sol";
import "../ERC20/IERC20.sol";
interface IRecoveryHub {
/*//////////////////////////////////////////////////////////////
Custom errors
//////////////////////////////////////////////////////////////*/
/// Recovery can be disabled per address.
/// @param lostAddress The address for which the recovery is disabled.
error RecoveryHub_RecoveryDisabled(address lostAddress);
/// No valid collateral type
/// @param collateralType The address of collateral type token
error RecoveryHub_BadCollateral(IERC20 collateralType);
/// No token to able to recover on the lost address
/// @param token The token address which is checked for recovery.
/// @param lostAddress The lost address.
error RecoveryHub_NothingToRecover(IERC20 token, address lostAddress);
/// The was already a claim for this token and address.
/// @param token The token address.
/// @param lostAddress The lost address.
error RecoveryHub_AlreadyClaimed(IERC20 token, address lostAddress);
/// Sender has to be claimant
/// @param sender The msg.sender of the call
error RecoveryHub_InvalidSender(address sender);
/// No claim for this address exists
/// @param lostAddress The checked address
error RecoveryHub_ClaimNotFound(address lostAddress);
/// Recover can only be called after the claim period
/// @param claimPeriodEnd The timestamp when the period ends
/// @param currentTimestamp The block timestamp of the call
error RecoveryHub_InClaimPeriod(uint256 claimPeriodEnd, uint256 currentTimestamp);
function setRecoverable(bool flag) external;
// deletes claim and transfers collateral back to claimer
function deleteClaim(address target) external;
// clears claim and transfers collateral to holder
function clearClaimFromToken(address holder) external;
function clearClaimFromUser(IRecoverable token) external;
}
/**
* SPDX-License-Identifier: LicenseRef-Aktionariat
*
* MIT License with Automated License Fee Payments
*
* Copyright (c) 2022 Aktionariat AG (aktionariat.com)
*
* Permission is hereby granted to any person obtaining a copy of this software
* and associated documentation files (the "Software"), to deal in the Software
* without restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies of the
* Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* - The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* - All automated license fee payments integrated into this and related Software
* are preserved.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
pragma solidity ^0.8.0;
import "../recovery/ERC20Recoverable.sol";
import "../draggable/ERC20Draggable.sol";
import "../ERC20/ERC20PermitLight.sol";
import "../ERC20/ERC20Permit2.sol";
/**
* @title CompanyName AG Shares SHA
* @author Luzius Meisser, [email protected]
*
* This is an ERC-20 token representing share tokens of CompanyName AG that are bound to
* a shareholder agreement that can be found at the URL defined in the constant 'terms'.
*/
contract DraggableShares is ERC20Draggable, ERC20Recoverable, ERC20PermitLight, ERC20Permit2 {
// Version history:
// 1: pre permit
// 2: includes permit
// 3: added permit2 allowance, VERSION field
uint8 public constant VERSION = 3;
string public terms;
/// Event when the terms are changed with setTerms().
event ChangeTerms(string terms);
constructor(
string memory _terms,
DraggableParams memory _params,
IRecoveryHub _recoveryHub,
IOfferFactory _offerFactory,
address _oracle,
Permit2Hub _permit2Hub
)
ERC20Draggable(_params, _offerFactory, _oracle)
ERC20Recoverable(_recoveryHub)
ERC20PermitLight()
ERC20Permit2(_permit2Hub)
{
terms = _terms; // to update the terms, migrate to a new contract. That way it is ensured that the terms can only be updated when the quorom agrees.
_recoveryHub.setRecoverable(false);
}
function transfer(address to, uint256 value) virtual override(IERC20, ERC20Flaggable, ERC20Recoverable) public returns (bool) {
return super.transfer(to, value);
}
/**
* Let the oracle act as deleter of invalid claims. In earlier versions, this was referring to the claim deleter
* of the wrapped token. But that stops working after a successful acquisition as the acquisition currency most
* likely does not have a claim deleter.
*/
function getClaimDeleter() public view override returns (address) {
return oracle;
}
function getCollateralRate(IERC20 collateralType) public view override returns (uint256) {
uint256 rate = super.getCollateralRate(collateralType);
if (rate > 0) {
return rate;
} else {
// as long as it is binding, the conversion rate is 1:1
uint256 factor = isBinding() ? 1 : unwrapConversionFactor;
if (address(collateralType) == address(wrapped)) {
// allow wrapped token as collateral
return factor;
} else {
// If the wrapped contract allows for a specific collateral, we should too.
// If the wrapped contract is not IRecoverable, we will fail here, but would fail anyway.
return IRecoverable(address(wrapped)).getCollateralRate(collateralType) * factor;
}
}
}
/**
* @notice This function allows the oracle to set the terms.
* @param _terms The new terms.
*/
function setTerms(string calldata _terms) external override onlyOracle {
terms = _terms;
emit ChangeTerms(terms);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) virtual override(ERC20Flaggable, ERC20Draggable) internal {
super._beforeTokenTransfer(from, to, amount);
}
function allowance(address owner, address spender) public view virtual override(ERC20Permit2, ERC20Flaggable, IERC20) returns (uint256) {
return super.allowance(owner, spender);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../ERC20/IERC20.sol";
interface IShares is IERC20 {
/*//////////////////////////////////////////////////////////////
Custom errors
//////////////////////////////////////////////////////////////*/
/// New total shares can't be below current valid supply
/// @param totalSupply The current valid supply.
/// @param newTotalShares The new max shares.
error Shares_InvalidTotalShares(uint256 totalSupply, uint256 newTotalShares);
/// Array lengths have to be equal.
/// @param targets Array length of targets.
/// @param amount Array length of amounts.
error Shares_UnequalLength(uint256 targets, uint256 amount);
/// It isn't possible to mint more share token than max shares in existens.
/// @param totalShares The max amount of shares.
/// @param needed The max amount of shares needed (current valid supply + new mint amount).
error Shares_InsufficientTotalShares(uint256 totalShares, uint256 needed);
function burn(uint256) external;
function totalShares() external view returns (uint256);
}
// SPDX-License-Identifier: MIT
// Copied from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol
// and modified it.
pragma solidity ^0.8.0;
library Address {
/// @param target Target address to call the function on.
error Address_NotTransferNorContract(address target);
/**
* @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
* ====
*/
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 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 or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* 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.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
function functionCallWithValue(address target, bytes memory data, uint256 weiValue) internal returns (bytes memory) {
if (data.length != 0 && !isContract(target)) {
revert Address_NotTransferNorContract(target);
}
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else if (returndata.length > 0) {
assembly{
revert (add (returndata, 0x20), mload (returndata))
}
} else {
revert("failed");
}
}
}
// SPDX-License-Identifier: MIT
//
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol
//
// Modifications:
// - Replaced Context._msgSender() with msg.sender
// - Made leaner
// - Extracted interface
pragma solidity ^0.8.0;
/**
* @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.
*/
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
error Ownable_NotOwner(address sender);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor (address initialOwner) {
owner = initialOwner;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) external onlyOwner {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function _checkOwner() internal view {
if (msg.sender != owner) {
revert Ownable_NotOwner(msg.sender);
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
import "../utils/Ownable.sol";
/// @title Permit2Hub
/// @dev This contract manages the Permit2 functionality and access control.
contract Permit2Hub is Ownable {
/// @dev The address of the Permit2 contract.
address public immutable permit2;
/// @dev Flag to indicate whether Permit2 is disabled.
bool public permit2Disabled = false;
/// @dev Mapping to track addresses for which Permit2 is disabled.
mapping(address => bool) public permit2DisabledForAddress;
/// @dev Emitted when the Permit2 setting is changed.
event ChangedPermit2(bool newSetting);
/// @dev Initializes the Permit2Hub contract with the provided Permit2 address and owner address.
/// @param _permit2 The address of the Permit2 contract.
/// @param _owner The address of the owner.
constructor(address _permit2, address _owner) Ownable(_owner) {
permit2 = _permit2;
}
/// @dev Checks if Permit2 is enabled for the given owner and spender addresses.
/// @param owner The owner address.
/// @param spender The spender address, needs to be the permit2 contract.
/// @return A boolean indicating whether Permit2 is enabled.
function isPermit2Enabled(address owner, address spender) public view returns (bool){
return spender == permit2 && !permit2Disabled && !permit2DisabledForAddress[owner];
}
/// @dev Toggles the global Permit2 setting. Can only be called by the owner.
function togglePermit2() external onlyOwner {
permit2Disabled = !permit2Disabled;
emit ChangedPermit2(permit2Disabled);
}
/// @dev Sets the Permit2 status for a specific address.
/// @param enabled The status to set for the address.
function setPermit2(bool enabled) external {
permit2DisabledForAddress[msg.sender] = !enabled;
}
}
// SPDX-License-Identifier: MIT
// coppied and adjusted from OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../ERC20/IERC20.sol";
import {IERC20Permit} from "../ERC20/IERC20Permit.sol";
import {Address} from "./Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev An operation with an ERC20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev 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);
if (nonceAfter != nonceBefore + 1) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}