Description:
Multi-signature wallet contract requiring multiple confirmations for transaction execution.
Blockchain: Ethereum
Source Code: View Code On The Blockchain
Solidity Source Code:
{{
"language": "Solidity",
"sources": {
"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
"
},
"@openzeppelin/contracts/access/Ownable.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {Context} from "../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.
*
* The initial owner is set to the address provided by the deployer. 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;
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @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 {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @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 {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_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);
}
}
"
},
"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.20;
/**
* @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.
*
* ==== Security Considerations
*
* There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
* expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
* considered as an intention to spend the allowance in any specific way. The second is that because permits have
* built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
* take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
* generally recommended is:
*
* ```solidity
* function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
* try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
* doThing(..., value);
* }
*
* function doThing(..., uint256 value) public {
* token.safeTransferFrom(msg.sender, address(this), value);
* ...
* }
* ```
*
* Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
* `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
* {SafeERC20-safeTransferFrom}).
*
* Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
* contracts should have entry points that don't rely on permit.
*/
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].
*
* CAUTION: See Security Considerations above.
*/
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);
}
"
},
"@openzeppelin/contracts/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @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 value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` 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 value) external returns (bool);
}
"
},
"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev An operation with an ERC20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}
"
},
"@openzeppelin/contracts/utils/Address.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @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.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
/**
* @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);
}
/**
* @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`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) 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 FailedInnerCall();
}
}
}
"
},
"@openzeppelin/contracts/utils/Context.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
/**
* @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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
"
},
"contracts/interface/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* @title IERC20Extended
* @dev Interface for extended ERC20 token standard with additional metadata functions
*/
interface IERC20Extended is IERC20 {
/**
* @notice Returns the name of the token
* @return string The name of the token
*/
function name() external view returns (string memory);
/**
* @notice Returns the symbol of the token
* @return string The symbol of the token
*/
function symbol() external view returns (string memory);
/**
* @notice Returns the number of decimals used to get its user representation
* @return uint8 The number of decimals
*/
function decimals() external view returns (uint8);
/**
* @notice Returns the total token supply
* @return uint The total supply of the token
*/
function totalSupply() external view returns (uint);
/**
* @notice Returns the account balance of another account with address `owner`
* @param owner The address of the account to query the balance of
* @return uint The account balance of the specified address
*/
function balanceOf(address owner) external view returns (uint);
/**
* @notice Returns the amount which `spender` is still allowed to withdraw from `owner`
* @param owner The address which owns the funds
* @param spender The address which will spend the funds
* @return uint The remaining amount allowed to be spent
*/
function allowance(address owner, address spender) external view returns (uint);
/**
* @notice Approves the passed address to spend the specified amount of tokens on behalf of msg.sender
* @param spender The address which will spend the funds
* @param value The amount of tokens to be spent
* @return bool True if the operation was successful
*/
function approve(address spender, uint value) external returns (bool);
/**
* @notice Transfers `value` amount of tokens to address `to`
* @param to The address of the recipient
* @param value The amount of tokens to be transferred
* @return bool True if the operation was successful
*/
function transfer(address to, uint value) external returns (bool);
/**
* @notice Transfers `value` amount of tokens from address `from` to address `to`
* @param from The address of the sender
* @param to The address of the recipient
* @param value The amount of tokens to be transferred
* @return bool True if the operation was successful
*/
function transferFrom(address from, address to, uint value) external returns (bool);
}
"
},
"contracts/interface/SecondSwap_IMarketplaceSetting.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* @title Marketplace Settings Interface
* @author darel
* @notice Interface for accessing marketplace configuration and settings
* @dev Defines required functions for marketplace setting implementations
*/
interface IMarketplaceSetting {
/**
* @notice Gets the current buyer fee percentage
* @dev Fee is in basis points (100 = 1%)
* @return Current buyer fee percentage
*/
function buyerFee() external view returns (uint256);
/**
* @notice Gets the current seller fee percentage
* @dev Fee is in basis points (100 = 1%)
* @return Current seller fee percentage
*/
function sellerFee() external view returns (uint256);
/**
* @notice Gets the current early unlisting penalty fee
* @dev Fee is denominated in wei
* @return Current penalty fee amount
*/
function penaltyFee() external view returns (uint256);
/**
* @notice Gets the minimum duration a listing must remain active
* @dev Duration is in seconds
* @return Minimum listing duration
*/
function minListingDuration() external view returns (uint256);
/**
* @notice Gets the referral reward percentage
* @dev Percentage is in basis points (100 = 1%)
* @return Current referral fee percentage
*/
function referralFee() external view returns (uint256);
/**
* @notice Checks if the marketplace is currently frozen
* @dev When true, most marketplace operations are disabled
* @return Current freeze status
*/
function isMarketplaceFreeze() external view returns (bool);
/**
* @notice Gets the address that collects marketplace fees
* @dev This address receives all fees from marketplace operations
* @return Address of the fee collector
*/
function feeCollector() external view returns (address);
/**
* @notice Gets the marketplace admin address
* @dev Admin has special privileges for marketplace management
* @return Address of the marketplace admin
*/
function s2Admin() external view returns (address);
/**
* @notice Gets the whitelist deployer contract address
* @dev This contract handles creation of whitelist contracts for private sales
* @return Address of the whitelist deployer contract
*/
function whitelistDeployer() external view returns (address);
/**
* @notice Gets the vesting manager contract address
* @dev This contract handles vesting operations and settings
* @return Address of the vesting manager contract
*/
function vestingManager() external view returns (address);
/**
* @notice Gets the USDT token contract address
* @dev Returns the address of the USDT token contract used by the marketplace
* @return Address of the USDT contract in IERC20 format
*/
function usdt() external view returns (IERC20);
/**
* @notice Gets buyer and seller fees for a specific vesting plan
* @dev Returns -1 for fees if using default marketplace fees
* @param _vesting Address of the vesting contract to check
* @return VPbuyerFee Buyer fee for the specific vesting plan (-1 for default)
* @return VPsellerFee Seller fee for the specific vesting plan (-1 for default)
*/
function getVestingFees(
address _vesting
) external view returns (int256 VPbuyerFee, int256 VPsellerFee);
}
"
},
"contracts/interface/SecondSwap_IVestingManager.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/**
* @title Vesting Manager Interface
* @author darel
* @notice Defines core functionality for managing vesting operations in the marketplace
* @dev Interface for marketplace interaction with vesting operations and settings
*/
interface IVestingManager {
/**
* @notice Settings structure for vesting contracts
* @dev Stores configuration for each vesting contract
* @param sellable Whether tokens from this vesting can be sold
* @param maxSellPercent Maximum percentage of tokens that can be sold (in basis points)
* @param buyerFee Fee charged to buyers (-1 for default fee)
* @param sellerFee Fee charged to sellers (-1 for default fee)
*/
struct VestingSettings {
bool sellable;
uint256 maxSellPercent;
int256 buyerFee;
int256 sellerFee;
bool initialized;
}
/**
* @notice Lists vested tokens for sale in the marketplace
* @dev Can only be called by the marketplace contract
* @param seller Address of the token seller
* @param plan Address of the vesting plan
* @param amount Amount of tokens to list
*/
function listVesting(
address seller,
address plan,
uint256 amount,
uint256 listingId
) external;
/**
* @notice Removes tokens from marketplace listing
* @dev Can only be called by the marketplace contract
* @param seller Address of the token seller
* @param plan Address of the vesting plan
* @param amount Amount of tokens to unlist
*/
function unlistVesting(
address seller,
address plan,
uint256 amount,
uint256 listingId
) external;
/**
* @notice Completes a purchase transaction
* @dev Can only be called by the marketplace contract
* @param buyer Address of the token buyer
* @param vesting Address of the vesting contract
* @param amount Amount of tokens purchased
*/
// function completePurchase(address buyer, address vesting, uint256 amount) external;
function completePurchase(
address buyer,
address vesting,
uint256 amount,
uint256 listingId
) external;
/**
* @notice Sets whether tokens can be sold from a vesting contract
* @dev Controls ability to list tokens from this vesting
* @param vesting Address of the vesting contract
* @param sellable Whether tokens should be sellable
*/
function setSellable(address vesting, bool sellable) external;
/**
* @notice Sets maximum percentage of tokens that can be sold
* @dev Percentage is in basis points (100 = 1%)
* @param vesting Address of the vesting contract
* @param maxSellPercent Maximum sell percentage in basis points
*/
function setMaxSellPercent(
address vesting,
uint256 maxSellPercent
) external;
/**
* @notice Sets the buyer fee for a specific vesting contract
* @dev Fee can be -1 to use default marketplace fee
* @param vesting Address of the vesting contract
* @param fee Buyer fee in basis points, -1 for default
*/
function setBuyerFee(address vesting, int256 fee) external;
/**
* @notice Sets the seller fee for a specific vesting contract
* @dev Fee can be -1 to use default marketplace fee
* @param vesting Address of the vesting contract
* @param fee Seller fee in basis points, -1 for default
*/
function setSellerFee(address vesting, int256 fee) external;
/**
* @notice Gets the current buyer and seller fees for a vesting plan
* @dev Returns -1 for fees if using default marketplace fees
* @param _vestingPlan Address of the vesting plan to check
* @return buyerFee Current buyer fee (-1 for default)
* @return sellerFee Current seller fee (-1 for default)
*/
function getVestingFees(
address _vestingPlan
) external view returns (int256 buyerFee, int256 sellerFee);
/**
* @notice Gets the ERC20 token address associated with a vesting plan
* @dev Can only be called by the marketplace contract
* @param _vestingPlan Address of the vesting plan contract
* @return _token Address of the ERC20 token being vested
*/
function getVestingTokenAddress(
address _vestingPlan
) external view returns (address _token);
/**
* @notice Reallocates vesting between two addresses
* @param _grantor Address of the original grantor
* @param _newGrantor Address of the new grantor
*/
function reallocateVesting(address _grantor, address _newGrantor, address vesting) external;
}
"
},
"contracts/interface/SecondSwap_IWhitelist.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
/**
* @title Whitelist Interface
* @author darel
* @notice Defines the interface for whitelist validation in private sales
* @dev Minimal interface for checking if addresses are whitelisted
*/
interface IWhitelist {
/**
* @notice Validates if an address is whitelisted
* @dev Should return true if the address is allowed to participate
* @param _userAddress The address to check whitelist status
* @return bool True if address is whitelisted, false otherwise
*/
function validateAddress(address _userAddress) external view returns (bool);
}
"
},
"contracts/SecondSwap_Marketplace.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "./interface/IERC20.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; // 3.6. DOS caused by the use of transfer and transferFrom functions
import "./interface/SecondSwap_IMarketplaceSetting.sol";
import "./interface/SecondSwap_IWhitelist.sol";
import "./interface/SecondSwap_IVestingManager.sol";
import "./SecondSwap_WhitelistDeployer.sol";
/**
* @title SecondSwap Marketplace Contract
* @notice Handles the listing and trading of vested tokens
* @dev This contract is upgradeable and manages the marketplace functionality for SecondSwap
*/
contract SecondSwap_Marketplace is Initializable {
using SafeERC20 for IERC20; // 3.6. DOS caused by the use of transfer and transferFrom functions
/**
* @notice Enumeration of possible listing statuses
* @dev Used to track the current state of a listing
* @param LIST Active listing that can be purchased
* @param SOLDOUT Listing where all tokens have been sold
* @param DELIST Listing that has been cancelled by the seller
*/
enum Status {
LIST,
SOLDOUT,
DELIST,
FREEZE
}
/**
* @notice Enumeration of listing types
* @dev Determines how tokens can be purchased from the listing
* @param PARTIAL Allows partial purchases of the listed amount
* @param SINGLE Requires the entire listed amount to be purchased at once
*/
enum ListingType {
PARTIAL,
SINGLE
}
/**
* @notice Enumeration of discount types
* @dev Defines how price discounts are calculated
* @param NO No discount applied
* @param LINEAR Discount increases linearly with purchase amount
* @param FIX Fixed percentage discount regardless of amount
*/
enum DiscountType {
NO,
LINEAR,
FIX
}
/**
* @notice Structure containing all listing information
* @dev Used to store and manage listing details
* @param seller Address of the token seller
* @param total Total amount of tokens initially listed
* @param balance Current remaining amount of tokens
* @param pricePerUnit Price per token unit
* @param listingType Type of listing (PARTIAL or SINGLE)
* @param discountType Type of discount applied
* @param discountPct Discount percentage (0-10000)
* @param listTime Timestamp when listing was created
* @param whitelist Address of whitelist contract if private listing
* @param minPurchaseAmt Minimum amount that can be purchased
* @param status Current status of the listing
* @param currency Address of token used for payment
*/
struct Listing {
address seller;
uint256 total;
uint256 balance;
uint256 pricePerUnit;
ListingType listingType;
DiscountType discountType;
uint256 discountPct;
uint256 listTime;
address whitelist;
uint256 minPurchaseAmt;
Status status;
address currency;
address vestingPlan;
}
/**
* @notice Address of the marketplace settings contract
* @dev Used to access marketplace configuration and parameters
*/
address public marketplaceSetting;
/**
* @notice Mapping of vesting plan addresses to their listing IDs and details
* @dev First key is vesting plan address, second key is listing ID
*/
mapping(address => mapping(uint256 => Listing)) public listings;
/**
* @notice Mapping of vesting plan addresses to their next available listing ID
* @dev Used to generate unique listing IDs for each vesting plan
*/
mapping(address => uint256) public nextListingId;
/**
* @notice Mapping of token addresses to their support status
* @dev Tracks which tokens are accepted as payment currency
*/
mapping(address => bool) public isTokenSupport;
/**
* @notice Base unit for percentage calculations
* @dev 10000 represents 100%, used for fee and discount calculations
*/
uint256 public constant BASE = 10000;
/**
* @notice Emitted when a new listing is created
* @param vestingPlan Address of the vesting plan contract
* @param listingId Unique identifier of the listing
*/
event Listed(address indexed vestingPlan, uint256 indexed listingId);
/**
* @notice Emitted when a listing is delisted
* @param vestingPlan Address of the vesting plan contract
* @param listingId Unique identifier of the listing
* @param penaltyFee Amount of penalty fee charged for early delisting
* @param seller Address of the seller who delisted
*/
event Delisted(address indexed vestingPlan, uint256 indexed listingId, uint256 penaltyFee, address seller);
/**
* @notice Emitted when a purchase is completed
* @param vestingPlan Address of the vesting plan contract
* @param listingId Unique identifier of the listing
* @param buyer Address of the buyer
* @param amount Amount of tokens purchased
* @param referral Address of the referrer
* @param buyerFee Amount of fees paid by buyer
* @param sellerFee Amount of fees paid by seller
* @param referralReward Amount of reward paid to referrer
*/
event Purchased(
address indexed vestingPlan,
uint256 indexed listingId,
address buyer,
uint256 amount,
address referral,
uint256 buyerFee,
uint256 sellerFee,
uint256 referralReward
);
/**
* @notice Emitted when a whitelist is created for a private listing
* @param vestingPlan Address of the vesting plan contract
* @param listingId Unique identifier of the listing
* @param whitelistAddress Address of the deployed whitelist contract
* @param seller Address of the seller
* @param maxWhitelist Maximum number of addresses that can be whitelisted
*/
event WhitelistCreated(
address indexed vestingPlan,
uint256 indexed listingId,
address whitelistAddress,
address seller,
uint256 maxWhitelist
);
/**
* @notice Emitted when a new token is added
* @param token address ot the new token
*/
event CoinAdded(address indexed token);
/**
* @notice Emitted when a listing is frozen
* @param vestingPlan Address of the vesting plan contract
* @param listingId Unique identifier of the listing
*/
event LotFrozen(address indexed vestingPlan, uint256 indexed listingId);
/**
* @notice Emitted when a listing is unfrozen
* @param vestingPlan Address of the vesting plan contract
* @param listingId Unique identifier of the listing
*/
event LotUnfrozen(address indexed vestingPlan, uint256 indexed listingId);
/**
* @notice Initializes the marketplace contract
* @dev Implementation of initializer for upgradeable contract pattern
* @param _token Initial supported token address for payments
* @param _marketplaceSetting Address of the marketplace settings contract
*/
function initialize(address _token, address _marketplaceSetting) public initializer {
isTokenSupport[_token] = true;
marketplaceSetting = _marketplaceSetting;
}
/**
* @notice Modifier to prevent actions when marketplace is frozen
* @dev Checks marketplace freeze status through settings contract
* @custom:throws SS_Marketplace: Marketplace is currently frozen
*/
modifier isFreeze() {
require(
!IMarketplaceSetting(marketplaceSetting).isMarketplaceFreeze(),
"SS_Marketplace: Marketplace is currently frozen"
);
_;
}
/**
* @notice Adds a new token as supported payment currency
* @dev Only callable by marketplace admin
* @param _token Address of the token to add as supported currency
* @custom:throws SS_Marketplace: Unauthorized user - If caller is not admin
* @custom:throws SS_Marketplace: Token is currently supported - If token already supported
*/
function addCoin(address _token) external {
require(msg.sender == IMarketplaceSetting(marketplaceSetting).s2Admin(), "SS_Marketplace: Unauthorized user");
require(!isTokenSupport[_token], "SS_Marketplace: Token is currently supported");
isTokenSupport[_token] = true;
emit CoinAdded(_token);
}
/**
* @notice Creates a new listing for vested tokens
* @dev Transfers tokens to marketplace and creates listing record
* @param _vestingPlan Address of the vesting plan contract
* @param _amount Total amount of tokens to list
* @param _price Price per token unit
* @param _discountPct Discount percentage (0-10000)
* @param _listingType PARTIAL allows partial fills, SINGLE requires complete fill
* @param _discountType NO = no discount, LINEAR = progressive, FIX = fixed percentage
* @param _maxWhitelist Maximum number of addresses for whitelist (if private)
* @param _currency Address of token used for payment
* @param _minPurchaseAmt Minimum purchase amount allowed
* @param _isPrivate If true, creates whitelist for private sale
* @custom:throws SS_Marketplace: Minimum Purchase Amount cannot be more than listing amount
* @custom:throws SS_Marketplace: Price must be greater than 0
* @custom:throws SS_Marketplace: Invalid discount amount
* @custom:throws SS_Marketplace: Invalid listing amount
* @custom:throws SS_Marketplace: Payment token is not supported
* @custom:throws SS_Marketplace: Minimum whitelist user cannot be 0
*/
function listVesting(
address _vestingPlan,
uint256 _amount,
uint256 _price,
uint256 _discountPct,
ListingType _listingType,
DiscountType _discountType,
uint256 _maxWhitelist, // kept for compatibility
address _currency,
uint256 _minPurchaseAmt,
bool _isPrivate // kept for compatibility
) external isFreeze {
require(
_listingType == ListingType.SINGLE || (_minPurchaseAmt >= 0 && _minPurchaseAmt <= _amount),
"SS_Marketplace: Minimum Purchase Amount cannot be more than listing amount"
);
require(_price > 0, "SS_Marketplace: Price must be greater than 0");
require(
(_discountType != DiscountType.NO && _discountPct > 0 && _discountPct <= 10000) || (_discountType == DiscountType.NO), // 3.4. SecondSwap_Marketplace::listVestingismissingacheckfor_discount Pct
"SS_Marketplace: Invalid discount amount"
);
require(_amount > 0, "SS_Marketplace: Invalid listing amount");
require(isTokenSupport[_currency], "SS_Marketplace: Payment token is not supported");
require(
doesFunctionExist(
address(
IVestingManager(IMarketplaceSetting(marketplaceSetting).vestingManager()).getVestingTokenAddress(
_vestingPlan
)
),
"decimals()"
),
"SS_Marketplace: No decimals function"
);
uint256 listingId = nextListingId[_vestingPlan]++;
IVestingManager(IMarketplaceSetting(marketplaceSetting).vestingManager()).listVesting(
msg.sender, _vestingPlan, _amount, listingId
);
address whitelistAddress;
// if (_isPrivate) {
// require(_maxWhitelist > 0, "SS_Marketplace: Minimum whitelist user cannot be 0");
// whitelistAddress = SecondSwap_WhitelistDeployer(IMarketplaceSetting(marketplaceSetting).whitelistDeployer())
// .deployWhitelist(_maxWhitelist, msg.sender);
// emit WhitelistCreated(_vestingPlan, listingId, whitelistAddress, msg.sender, _maxWhitelist);
// }
listings[_vestingPlan][listingId] = Listing({
seller: msg.sender,
total: _amount,
balance: _amount,
pricePerUnit: _price,
listingType: _listingType,
discountType: _discountType,
discountPct: _discountPct,
listTime: block.timestamp,
whitelist: whitelistAddress,
currency: _currency,
minPurchaseAmt: _minPurchaseAmt,
status: Status.LIST,
vestingPlan: _vestingPlan
});
require(
!_isZeroBaseAmountPossible(listings[_vestingPlan][listingId]), "SS_Marketplace: Zero base amount possible"
);
emit Listed(_vestingPlan, listingId);
}
/**
* @notice Checks if a listing configuration could result in zero base amount transactions
* @dev Validates both minimum purchase and total amounts against price and discounts
* @param listing Storage pointer to the listing to validate
* @return bool True if zero base amount is possible, false otherwise
* @custom:calculation Calculates base amounts by multiplying price per unit with discounted prices
*/
function _isZeroBaseAmountPossible(Listing storage listing) private view returns (bool) {
uint256 pricePerUnit = listing.pricePerUnit;
uint256 minPurchaseAmt = listing.minPurchaseAmt;
uint256 total = listing.total;
uint256 decimals = IERC20Extended(address(listing.currency)).decimals();
uint256 baseAmountForMin = pricePerUnit * _getDiscountedPrice(listing, minPurchaseAmt) / (10 ** decimals);
uint256 baseAmountForTotal = pricePerUnit * _getDiscountedPrice(listing, total) / (10 ** decimals);
return baseAmountForMin == 0 || baseAmountForTotal == 0;
}
/**
* @notice Checks if a function exists on a target contract
* @dev Uses a static call to test if the function selector exists and executes successfully
* @param target Address of the contract to check
* @param functionSignature String representation of the function signature to check
* @return bool True if the function exists and can be called, false otherwise
* @custom:validation Uses static call to avoid state changes while checking
*/
function doesFunctionExist(address target, string memory functionSignature) public view returns (bool) {
bytes4 selector = bytes4(keccak256(bytes(functionSignature)));
(bool success,) = target.staticcall(abi.encodeWithSelector(selector));
return success;
}
/**
* @notice Removes a listing from the marketplace
* @dev Handles early unlisting penalties and token returns
* @param _vestingPlan Address of the vesting plan contract
* @param _listingId ID of the listing to remove
* @custom:throws SS_Marketplace: Listing not active
* @custom:throws SS_Marketplace: Not the seller
* @custom:throws SS_Marketplace: Penalty fee required for early unlisting
*/
function unlistVesting(address _vestingPlan, uint256 _listingId) external isFreeze {
Listing storage listing = listings[_vestingPlan][_listingId];
require(listing.status == Status.LIST, "SS_Marketplace: Listing not active");
require(
listing.seller == msg.sender || msg.sender == IMarketplaceSetting(marketplaceSetting).s2Admin(),
"SS_Marketplace: Not the seller"
);
uint256 _penaltyFee = 0;
if (msg.sender != IMarketplaceSetting(marketplaceSetting).s2Admin()) {
// 3.4. The s2Admin is unable to unlist vesting
if ((listing.listTime + IMarketplaceSetting(marketplaceSetting).minListingDuration()) > block.timestamp) {
require(
(IMarketplaceSetting(marketplaceSetting).usdt()).balanceOf(msg.sender)
>= IMarketplaceSetting(marketplaceSetting).penaltyFee(),
"SS_Marketplace: Penalty fee required for early unlisting"
);
(IMarketplaceSetting(marketplaceSetting).usdt()).safeTransferFrom(
msg.sender,
IMarketplaceSetting(marketplaceSetting).feeCollector(),
IMarketplaceSetting(marketplaceSetting).penaltyFee()
);
_penaltyFee = IMarketplaceSetting(marketplaceSetting).penaltyFee();
}
}
IVestingManager(IMarketplaceSetting(marketplaceSetting).vestingManager()).unlistVesting(
listing.seller, _vestingPlan, listing.balance, _listingId
);
listing.status = Status.DELIST;
listing.balance = 0;
emit Delisted(_vestingPlan, _listingId, _penaltyFee, msg.sender);
}
/**
* @notice Validates a purchase attempt
* @dev Checks various conditions that must be met for a valid purchase
* @param listing The listing to validate against
* @param _amount Amount of tokens to purchase
* @param _referral Address of the referrer
* @custom:throws SS_Marketplace: Invalid referral
* @custom:throws SS_Marketplace: Not whitelisted
* @custom:throws SS_Marketplace: Invalid Purchase amount
* @custom:throws SS_Marketplace: Invalid amount
* @custom:throws SS_Marketplace: Insufficient
*/
function _validatePurchase(Listing storage listing, uint256 _amount, address _referral) private view {
require(listing.status == Status.LIST, "SS_Marketplace: Listing not active");
require(msg.sender != _referral, "SS_Marketplace: Invalid referral");
// require(
// listing.whitelist == address(0) || IWhitelist(listing.whitelist).validateAddress(msg.sender),
// "SS_Marketplace: Not whitelisted"
// );
require(
listing.listingType == ListingType.SINGLE
|| (_amount >= listing.minPurchaseAmt || _amount == listing.balance),
"SS_Marketplace: Invalid Purchase amount"
);
require(listing.listingType != ListingType.SINGLE || _amount == listing.total, "SS_Marketplace: Invalid amount");
require(_amount <= listing.balance, "SS_Marketplace: Insufficient");
require(msg.sender != listing.seller, "SS_Marketplace: Cannot buy from yourself");
}
/**
* @notice Calculates the final price per token including discounts
* @dev Applies linear or fixed discounts based on listing configuration
* @param listing The listing to calculate price for
* @param _amount Amount of tokens being purchased
* @return Final price per token after discounts
*/
function _getDiscountedPrice(Listing storage listing, uint256 _amount) private view returns (uint256) {
uint256 discountedPrice = listing.pricePerUnit;
if (listing.discountType == DiscountType.LINEAR) {
discountedPrice = (discountedPrice * (BASE - ((_amount * listing.discountPct) / listing.total))) / BASE;
} else if (listing.discountType == DiscountType.FIX) {
discountedPrice = (discountedPrice * (BASE - listing.discountPct)) / BASE;
}
return discountedPrice;
}
/**
*
* @notice Retrieves buyer and seller fee rates for a vesting plan
* @dev Checks for plan-specific fees, falls back to global fees if not set
* @param _vestingPlan Address of the vesting plan
* @return bfee Buyer fee percentage
* @return sfee Seller fee percentage
*/
function _getFees(address _vestingPlan) private view returns (uint256 bfee, uint25Submitted on: 2025-10-21 12:18:05
Comments
Log in to comment.
No comments yet.