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/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/interfaces/draft-IERC6093.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/draft-IERC6093.sol)
pragma solidity >=0.8.4;
/**
* @dev Standard ERC-20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC-721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC-1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
"
},
"@openzeppelin/contracts/interfaces/IERC1363.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)
pragma solidity >=0.6.2;
import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";
/**
* @title IERC1363
* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
*
* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
*/
interface IERC1363 is IERC20, IERC165 {
/*
* Note: the ERC-165 identifier for this interface is 0xb0202a11.
* 0xb0202a11 ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @param data Additional data with no specified format, sent in call to `spender`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}
"
},
"@openzeppelin/contracts/interfaces/IERC165.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)
pragma solidity >=0.4.16;
import {IERC165} from "../utils/introspection/IERC165.sol";
"
},
"@openzeppelin/contracts/interfaces/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)
pragma solidity >=0.4.16;
import {IERC20} from "../token/ERC20/IERC20.sol";
"
},
"@openzeppelin/contracts/token/ERC20/ERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.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}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC-20
* applications.
*/
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* Both values are immutable: they can only be set once during construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/// @inheritdoc IERC20
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
/// @inheritdoc IERC20
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/// @inheritdoc IERC20
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Skips emitting an {Approval} event indicating an allowance update. This is not
* required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
* (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
* this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
_totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
/**
* @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
* true using the following override:
*
* ```solidity
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner`'s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Does not emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance < type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
"
},
"@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)
pragma solidity ^0.8.20;
import {ERC20} from "../ERC20.sol";
import {Context} from "../../../utils/Context.sol";
/**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys a `value` amount of tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 value) public virtual {
_burn(_msgSender(), value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, deducting from
* the caller's allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `value`.
*/
function burnFrom(address account, uint256 value) public virtual {
_spendAllowance(account, _msgSender(), value);
_burn(account, value);
}
}
"
},
"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity >=0.6.2;
import {IERC20} from "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC-20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
"
},
"@openzeppelin/contracts/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)
pragma solidity >=0.4.16;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
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.3.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC-20 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 {
/**
* @dev An operation with an ERC-20 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 Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
*/
function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
*/
function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
return _callOptionalReturnBool(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.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
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.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
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.
*
* NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
* only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
* set here.
*/
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 Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
safeTransfer(token, to, value);
} else if (!token.transferAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
* has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferFromAndCallRelaxed(
IERC1363 token,
address from,
address to,
uint256 value,
bytes memory data
) internal {
if (to.code.length == 0) {
safeTransferFrom(token, from, to, value);
} else if (!token.transferFromAndCall(from, to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
* Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
* once without retrying, and relies on the returned value to be true.
*
* Reverts if the returned value is other than `true`.
*/
function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
forceApprove(token, to, value);
} else if (!token.approveAndCall(to, value, data)) {
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 {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
// bubble errors
if iszero(success) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
returnSize := returndatasize()
returnValue := mload(0)
}
if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 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).
*
* This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
bool success;
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
returnSize := returndatasize()
returnValue := mload(0)
}
return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
}
}
"
},
"@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;
}
}
"
},
"@openzeppelin/contracts/utils/introspection/IERC165.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)
pragma solidity >=0.4.16;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
"
},
"contracts/IVMToken.sol": {
"content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
/*
* IVM Token (ivm) – ERC20 with allocations, vesting, loyalty vault, and burn mechanics.
* Supply: 500,000,000 IVM
* - Community: 15% (immediate)
* - Marketing: 5% (unlock 4 months after launch)
* - Development & Tech: 5% (unlock 2027-02-01)
* - Loyalty & Rewards: 5% (unlock 2026-12-31)
* - Team: 10% (2-year cliff, then 5% every 6 months)
* - Reserve: 60% (5% every 2 years after a 2-year cliff)
*
* Burns:
* - Voluntary burn (ERC20Burnable)
* - Owner burn from owner balance
* - Optional auto-burn on transfers (≤2%) with exemptions
* - Buy-only burn: 0.08% when buying from liquidity pair
*/
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
/// -----------------------------------------------------------------------
/// TrancheVestingWallet (OZ v5 Ownable)
/// -----------------------------------------------------------------------
contract TrancheVestingWallet is Ownable {
using SafeERC20 for IERC20;
IERC20 public immutable token;
address public beneficiary;
uint256 public immutable start; // first release time
uint256 public immutable period; // seconds per tranche
uint256 public immutable totalTranches; // number of tranches
uint256 public released; // total released so far
event Released(uint256 amount, uint256 totalReleased);
event BeneficiaryUpdated(address indexed oldB, address indexed newB);
constructor(
IERC20 _token,
address _beneficiary,
uint256 _start,
uint256 _period,
uint256 _totalTranches,
address _owner
) Ownable(_owner) {
require(address(_token) != address(0), "token=0");
require(_beneficiary != address(0), "beneficiary=0");
require(_period > 0, "period=0");
require(_totalTranches > 0, "tranches=0");
token = _token;
beneficiary = _beneficiary;
start = _start;
period = _period;
totalTranches = _totalTranches;
}
function setBeneficiary(address newBeneficiary) external onlyOwner {
require(newBeneficiary != address(0), "beneficiary=0");
emit BeneficiaryUpdated(beneficiary, newBeneficiary);
beneficiary = newBeneficiary;
}
function releasable() public view returns (uint256) {
return _vestedAmount() - released;
}
function release() external {
uint256 amount = releasable();
require(amount > 0, "nothing releasable");
released += amount;
token.safeTransfer(beneficiary, amount);
emit Released(amount, released);
}
function _vestedAmount() internal view returns (uint256) {
uint256 totalAllocation = token.balanceOf(address(this)) + released;
if (block.timestamp < start) return 0;
uint256 elapsedTranches = ((block.timestamp - start) / period) + 1;
if (elapsedTranches > totalTranches) elapsedTranches = totalTranches;
return (totalAllocation * elapsedTranches) / totalTranches;
}
}
/// -----------------------------------------------------------------------
/// LoyaltyVault (OZ v5 Ownable)
/// -----------------------------------------------------------------------
contract LoyaltyVault is Ownable {
using SafeERC20 for IERC20;
IERC20 public immutable token;
uint256 public immutable releaseTime;
address public admin;
event AdminUpdated(address indexed oldAdmin, address indexed newAdmin);
event Distributed(address indexed to, uint256 amount);
event Swept(address indexed to, uint256 amount);
constructor(
IERC20 _token,
uint256 _releaseTime,
address _admin,
address _owner
) Ownable(_owner) {
require(address(_token) != address(0), "token=0");
require(_admin != address(0), "admin=0");
token = _token;
releaseTime = _releaseTime;
admin = _admin;
}
modifier onlyAfterRelease() {
require(block.timestamp >= releaseTime, "locked");
_;
}
modifier onlyAdmin() {
require(msg.sender == admin || msg.sender == owner(), "not admin");
_;
}
function setAdmin(address newAdmin) external onlyOwner {
require(newAdmin != address(0), "admin=0");
emit AdminUpdated(admin, newAdmin);
admin = newAdmin;
}
function distribute(address to, uint256 amount)
external
onlyAfterRelease
onlyAdmin
{
require(to != address(0), "to=0");
token.safeTransfer(to, amount);
emit Distributed(to, amount);
}
function sweepRemaining(address to)
external
onlyAfterRelease
onlyOwner
{
require(to != address(0), "to=0");
uint256 bal = token.balanceOf(address(this));
token.safeTransfer(to, bal);
emit Swept(to, bal);
}
}
/// -----------------------------------------------------------------------
/// IVMToken (main token)
/// -----------------------------------------------------------------------
contract IVMToken is ERC20, ERC20Burnable, Ownable {
using SafeERC20 for IERC20;
// ===== Supply & Allocations =====
uint256 public constant TOTAL_SUPPLY = 500_000_000 * 1e18;
uint256 public constant COMMUNITY_AMT = 75_000_000 * 1e18; // 15%
uint256 public constant MARKETING_AMT = 25_000_000 * 1e18; // 5%
uint256 public constant DEV_TECH_AMT = 25_000_000 * 1e18; // 5%
uint256 public constant LOYALTY_AMT = 25_000_000 * 1e18; // 5%
uint256 public constant TEAM_AMT = 50_000_000 * 1e18; // 10%
uint256 public constant RESERVE_AMT = 300_000_000 * 1e18; // 60%
uint256 public constant MIN_CIRCULATING_SUPPLY = 21_000_000 * 1e18; // burn cap target
// ===== Timing =====
uint256 public immutable launchTime;
uint256 public constant TWO_YEARS = 730 days; // approx
uint256 public constant SIX_MONTHS = 182 days; // approx half-year
uint256 public constant FOUR_MONTHS = 120 days; // approx
uint256 public constant RESERVE_FIRST_RELEASE = 1_798_761_600; // 2027-01-01 00:00:00 UTC
uint256 public constant RESERVE_TRANCHES = 12; // 12 * 5% = 60%
uint256 public constant DEV_TECH_RELEASE_TIME = 1_801_440_000; // 2027-02-01 00:00:00 UTC
uint256 public constant LOYALTY_RELEASE_TIME = 1_798_675_200; // 2026-12-31 00:00:00 UTC
// ===== Wallets / Vaults =====
address public communityWallet;
address public marketingWallet;
TrancheVestingWallet public marketingVesting;
address public devTechWallet;
TrancheVestingWallet public devTechVesting;
TrancheVestingWallet public teamVesting;
TrancheVestingWallet public reserveVesting;
LoyaltyVault public loyaltyVault;
bool public allocationsInitialized;
bool private _isReleasing;
// ===== Burn Config =====
address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
address public burnWallet;
// Optional general auto-burn (off by default)
bool public autoBurnEnabled;
uint16 public autoBurnBps; // ≤ 200 (2%)
mapping(address => bool) public isExcludedFromAutoBurn;
// Buy-only burn (0.08%) when tokens move from liquidity pair to buyer
address public marketPair;
bool public buyBurnEnabled = true;
uint16 public buyBurnBps = 8; // 8 bps = 0.08%
uint256 public totalAutoBurned;
uint256 public totalBuyBurned;
uint256 public totalManualBurned;
uint256 public totalTokensSentToDead; // includes burns to address(0) and dead address
// ===== Events =====
event AllocationsInitialized(
address indexed community,
address indexed marketingBeneficiary,
address indexed devTechBeneficiary,
address marketingVesting,
address devTechVesting,
address teamVesting,
address reserveVesting,
address loyaltyVault
);
event AutoBurnUpdated(bool enabled, uint16 bps);
event ExcludedFromAutoBurn(address indexed account, bool excluded);
event MarketPairUpdated(address indexed pair);
event BuyBurnUpdated(bool enabled, uint16 bps);
event AutoBurn(address indexed from, address indexed wallet, uint256 amount);
event BuyBurn(address indexed buyer, address indexed wallet, uint256 amount);
event ManualBurn(address indexed from, address indexed wallet, uint256 amount);
event AllocationReleased(address indexed vault, address indexed beneficiary, uint256 amount);
event BurnWalletUpdated(address indexed previousWallet, address indexed newWallet);
constructor() ERC20("ivm", "IVM") Ownable(msg.sender) {
launchTime = block.timestamp;
_mint(address(this), TOTAL_SUPPLY);
burnWallet = DEAD;
emit BurnWalletUpdated(address(0), burnWallet);
}
// ===== Setup allocations (one-time) =====
function setupAllocations(
address _communityWallet,
address _marketingWallet,
address _devTechWallet,
address _teamBeneficiary,
address _reserveBeneficiary,
address _loyaltyAdmin
) external onlyOwner {
require(!allocationsInitialized, "already initialized");
require(_communityWallet != address(0), "community=0");
require(_marketingWallet != address(0), "marketing=0");
require(_devTechWallet != address(0), "devtech=0");
require(_teamBeneficiary != address(0), "team=0");
require(_reserveBeneficiary != address(0), "reserve=0");
require(_loyaltyAdmin != address(0), "loyalty=0");
communityWallet = _communityWallet;
marketingWallet = _marketingWallet;
devTechWallet = _devTechWallet;
isExcludedFromAutoBurn[communityWallet] = true;
isExcludedFromAutoBurn[marketingWallet] = true;
isExcludedFromAutoBurn[devTechWallet] = true;
// Marketing vesting: unlock 100% after 4 months
marketingVesting = new TrancheVestingWallet(
IERC20(address(this)),
marketingWallet,
launchTime + FOUR_MONTHS,
1 days,
1,
owner()
);
// Development & Tech vesting: unlock 100% on Feb 1, 2027 (or later if deployed after)
uint256 devStart = DEV_TECH_RELEASE_TIME;
if (devStart < launchTime) {
devStart = launchTime;
}
devTechVesting = new TrancheVestingWallet(
IERC20(address(this)),
devTechWallet,
devStart,
1 days,
1,
owner()
);
isExcludedFromAutoBurn[address(marketingVesting)] = true;
isExcludedFromAutoBurn[address(devTechVesting)] = true;
// Team vesting: 2-year cliff then 5% every 6 months (20 tranches of 5%)
teamVesting = new TrancheVestingWallet(
IERC20(address(this)),
_teamBeneficiary,
launchTime + TWO_YEARS,
SIX_MONTHS,
20,
owner()
);
// Reserve vesting: 2-year cliff then 5% every 2 years (12 tranches)
uint256 reserveStart = launchTime + TWO_YEARS;
if (reserveStart < RESERVE_FIRST_RELEASE) {
reserveStart = RESERVE_FIRST_RELEASE;
}
reserveVesting = new TrancheVestingWallet(
IERC20(address(this)),
_reserveBeneficiary,
reserveStart,
TWO_YEARS,
RESERVE_TRANCHES,
owner()
);
isExcludedFromAutoBurn[address(teamVesting)] = true;
isExcludedFromAutoBurn[address(reserveVesting)] = true;
// Loyalty & Rewards vault: distribution not allowed before 2026-12-31
loyaltyVault = new LoyaltyVault(
IERC20(address(this)),
LOYALTY_RELEASE_TIME,
_loyaltyAdmin,
owner()
);
isExcludedFromAutoBurn[address(loyaltyVault)] = true;
// Transfers of allocations
_transfer(address(this), communityWallet, COMMUNITY_AMT);
_transfer(address(this), address(marketingVesting), MARKETING_AMT);
_transfer(address(this), address(devTechVesting), DEV_TECH_AMT);
_transfer(address(this), address(teamVesting), TEAM_AMT);
_transfer(address(this), address(reserveVesting), RESERVE_AMT);
_transfer(address(this), address(loyaltyVault), LOYALTY_AMT);
// Exclude system wallets from auto-burn
allocationsInitialized = true;
emit AllocationsInitialized(
communityWallet,
marketingWallet,
devTechWallet,
address(marketingVesting),
address(devTechVesting),
address(teamVesting),
address(reserveVesting),
address(loyaltyVault)
);
}
// ===== Burn controls =====
function setAutoBurn(bool enabled, uint16 bps) external onlyOwner {
require(bps <= 200, "max 2%");
autoBurnEnabled = enabled;
autoBurnBps = bps;
emit AutoBurnUpdated(enabled, bps);
}
function setExcludedFromAutoBurn(address account, bool excluded) external onlyOwner {
require(account != address(0), "zero addr");
isExcludedFromAutoBurn[account] = excluded;
emit ExcludedFromAutoBurn(account, excluded);
}
function ownerBurn(uint256 amount) external onlyOwner {
_burn(msg.sender, amount);
}
function setBurnWallet(address newBurnWallet) external onlyOwner {
require(newBurnWallet != address(0), "burn wallet=0");
address previous = burnWallet;
burnWallet = newBurnWallet;
emit BurnWalletUpdated(previous, newBurnWallet);
}
// ===== Buy-only burn controls =====
function setMarketPair(address _pair) external onlyOwner {
require(_pair != address(0), "pair=0");
marketPair = _pair;
emit MarketPairUpdated(_pair);
}
function setBuyBurn(bool enabled, uint16 bps) external onlyOwner {
require(bps <= 100, "max 1%");
buyBurnEnabled = enabled;
buyBurnBps = bps;
emit BuyBurnUpdated(enabled, bps);
}
function releaseUnlockedAllocations() public {
_attemptAutoRelease();
}
// ===== Transfer hook with burn logic =====
function _update(address from, address to, uint256 value) internal virtual override {
if (!_isReleasing && allocationsInitialized) {
_attemptAutoRelease();
}
if (from != address(0) && to == address(0)) {
uint256 burnCapacity = _remainingBurnCapacity();
require(burnCapacity >= value, "burn cap reached");
super._update(from, to, value);
totalManualBurned += value;
totalTokensSentToDead += value;
emit ManualBurn(from, to, value);
return;
}
uint256 manualBurnAmount;
// A) Optional general auto-burn
if (
autoBurnEnabled &&
autoBurnBps > 0 &&
from != address(0) &&
to != address(0) &&
!isExcludedFromAutoBurn[from] &&
!isExcludedFromAutoBurn[to]
) {
uint256 burnAmt = (value * autoBurnBps) / 10_000;
uint256 burnCapacity = _remainingBurnCapacity();
if (burnAmt > burnCapacity) {
burnAmt = burnCapacity;
}
if (burnAmt > 0) {
super._update(from, burnWallet, burnAmt);
value -= burnAmt;
totalAutoBurned += burnAmt;
totalTokensSentToDead += burnAmt;
emit AutoBurn(from, burnWallet, burnAmt);
}
}
// B) Buy-only burn (0.08%) when from == marketPair (buy)
if (
buyBurnEnabled &&
marketPair != address(0) &&
from == marketPair &&
to != address(0) &&
!isExcludedFromAutoBurn[to]
) {
uint256 buyBurnAmount = (value * buyBurnBps) / 10_000;
uint256 burnCapacity = _remainingBurnCapacity();
if (buyBurnAmount > burnCapacity) {
buyBurnAmount = burnCapacity;
}
if (buyBurnAmount > 0) {
super._update(from, burnWallet, buyBurnAmount);
value -= buyBurnAmount;
totalBuyBurned += buyBurnAmount;
totalTokensSentToDead += buyBurnAmount;
emit BuyBurn(to, burnWallet, buyBurnAmount);
}
}
if ((to == burnWallet || to == DEAD) && from != address(0) && value > 0) {
require(_remainingBurnCapacity() >= value, "burn cap reached");
manualBurnAmount = value;
}
super._update(from, to, value);
if (manualBurnAmount > 0) {
totalManualBurned += manualBurnAmount;
totalTokensSentToDead += manualBurnAmount;
emit ManualBurn(from, to, manualBurnAmount);
}
}
// Safety: reject stray ETH
receive() external payable {
revert("No ETH accepted");
}
function _remainingBurnCapacity() private view returns (uint256) {
if (TOTAL_SUPPLY <= MIN_CIRCULATING_SUPPLY) {
return 0;
}
uint256 targetBurnTotal = TOTAL_SUPPLY - MIN_CIRCULATING_SUPPLY;
if (totalTokensSentToDead >= targetBurnTotal) {
return 0;
}
return targetBurnTotal - totalTokensSentToDead;
}
function _attemptAutoRelease() private {
if (_isReleasing || !allocationsInitialized) {
return;
}
_isReleasing = true;
_releaseIfReady(marketingVesting);
_releaseIfReady(devTechVesting);
_releaseIfReady(teamVesting);
_releaseIfReady(reserveVesting);
_isReleasing = false;
}
function _releaseIfReady(TrancheVestingWallet vesting) private {
address vestingAddress = address(vesting);
if (vestingAddress == address(0)) return;
uint256 amount = vesting.releasable();
if (amount == 0) return;
address beneficiary = vesting.beneficiary();
try vesting.release() {
emit AllocationReleased(vestingAddress, beneficiary, amount);
} catch {
// no-op: keep tokens locked if release reverts
}
}
}
"
}
},
"settings": {
"optimizer": {
"enabled": true,
"runs": 200
},
"evmVersion": "paris",
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
}
}
}}Submitted on: 2025-10-23 19:46:36
Comments
Log in to comment.
No comments yet.