TWIN MINT INSPECTOR

Account details

BNB Chain · Chain 56

0xBb2333D6446d8B6c2eF6F98b60D24e7022486863

Account typeDeployed contract

Native balance0 BNB

Runtime size8253 bytes

Deployed bytecode

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

Live on-chain data. Deployed code alone does not establish that a contract is safe or audited.

Published source

Published source matches the deployed contract. This is not a security audit.

src/TwinMintFactory.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import {Create3} from "../vendor/Create3.sol";
import {TwinToken} from "./TwinToken.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/// @notice Anyone can launch in their own namespace. No relayer or external init code.
contract TwinMintFactory is ReentrancyGuard {
    bytes32 public constant DOMAIN = keccak256("TwinMint.v1");
    bytes32 public constant PROXY_CODE_HASH = 0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f;
    address public feeRecipient;
    uint256 public creationFee;
    struct TokenConfig {
        string name; string symbol; uint8 decimals; uint256 supply;
        address recipient; uint256 creatorAmount; string metadataURI;
    }
    struct Launch { address creator; bytes32 pairId; address token; bytes32 configHash; uint64 timestamp; string pairURI; }
    mapping(bytes32 => Launch) private launches;
    bytes32[] private launchKeys;
    mapping(address => bytes32) private tokenKeys;
    event TwinDeployed(address indexed creator, bytes32 indexed pairId, address indexed token,
        bytes32 configHash, string pairURI, string metadataURI);
    error AlreadyDeployed();
    error IncorrectFee();

    // Identical constructor parameters are required on both chains for CREATE2 bootstrap.
    // Fees are immutable in practice: no administrative setter or upgrade mechanism.
    constructor(address recipient_, uint256 fee_) {
        require(fee_ == 0 || recipient_ != address(0), "Invalid fee recipient");
        feeRecipient = recipient_; creationFee = fee_;
    }
    function saltOf(address creator, bytes32 pairId) public pure returns (bytes32) {
        return keccak256(abi.encode(DOMAIN, creator, pairId));
    }
    function predict(address creator, bytes32 pairId) public view returns (address) {
        return Create3.addressOf(saltOf(creator, pairId));
    }
    function count() external view returns(uint256) { return launchKeys.length; }
    function getByToken(address token) external view returns(Launch memory) { return launches[tokenKeys[token]]; }
    function launchAt(uint256 index) external view returns(Launch memory) { return launches[launchKeys[index]]; }
    function getLaunch(address creator, bytes32 pairId) external view returns(Launch memory) {
        return launches[saltOf(creator, pairId)];
    }
    function deploy(bytes32 pairId, TokenConfig calldata cfg, string calldata pairURI)
        external payable nonReentrant returns(address token) {
        require(pairId != bytes32(0) && bytes(pairURI).length <= 2048, "Invalid pair");
        if(msg.value != creationFee) revert IncorrectFee();
        bytes32 salt = saltOf(msg.sender, pairId);
        if(launches[salt].token != address(0)) revert AlreadyDeployed();
        bytes32 configHash = keccak256(abi.encode(cfg));
        token = Create3.create3(salt, abi.encodePacked(type(TwinToken).creationCode,
            abi.encode(cfg.name, cfg.symbol, cfg.decimals, cfg.supply, msg.sender, pairId,
                cfg.metadataURI, cfg.recipient, cfg.creatorAmount, address(this))));
        launches[salt] = Launch(msg.sender, pairId, token, configHash, uint64(block.timestamp), pairURI);
        launchKeys.push(salt);
        tokenKeys[token] = salt;
        emit TwinDeployed(msg.sender, pairId, token, configHash, pairURI, cfg.metadataURI);
        if(msg.value != 0) {
            (bool ok,) = feeRecipient.call{value:msg.value}("");
            require(ok, "Fee transfer failed");
        }
    }
}

src/TwinToken.sol

// SPDX-License-Identifier: MIT
pragma solidity 0.8.30;

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

/// @notice Fixed supply, no owner, no taxes, no post-construction mint authority.
contract TwinToken is ERC20 {
    uint8 private immutable tokenDecimals;
    address public immutable creator;
    bytes32 public immutable pairId;
    address public immutable factory;
    string public metadataURI;

    constructor(string memory name_, string memory symbol_, uint8 decimals_, uint256 supply_,
        address creator_, bytes32 pairId_, string memory uri_, address recipient_,
        uint256 creatorAmount_, address factory_) ERC20(name_, symbol_) {
        require(bytes(name_).length > 0 && bytes(name_).length <= 64, "Invalid name");
        require(bytes(symbol_).length > 0 && bytes(symbol_).length <= 12, "Invalid symbol");
        require(decimals_ <= 18 && supply_ > 0 && creatorAmount_ <= supply_, "Invalid supply");
        require(creator_ != address(0) && recipient_ != address(0), "Zero recipient");
        require(bytes(uri_).length <= 2048, "Metadata too long");
        tokenDecimals = decimals_;
        creator = creator_;
        pairId = pairId_;
        factory = factory_;
        metadataURI = uri_;
        _mint(recipient_, creatorAmount_);
        _mint(creator_, supply_ - creatorAmount_);
    }
    function decimals() public view override returns (uint8) { return tokenDecimals; }
}

vendor/Create3.sol

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

/**
  @title A library for deploying contracts EIP-3171 style.
  @author Agustin Aguilar <aa@horizon.io>
*/
library Create3 {
  error ErrorCreatingProxy();
  error ErrorCreatingContract();
  error TargetAlreadyExists();

  /**
    @notice The bytecode for a contract that proxies the creation of another contract
    @dev If this code is deployed using CREATE2 it can be used to decouple `creationCode` from the child contract address

  0x67363d3d37363d34f03d5260086018f3:
      0x00  0x67  0x67XXXXXXXXXXXXXXXX  PUSH8 bytecode  0x363d3d37363d34f0
      0x01  0x3d  0x3d                  RETURNDATASIZE  0 0x363d3d37363d34f0
      0x02  0x52  0x52                  MSTORE
      0x03  0x60  0x6008                PUSH1 08        8
      0x04  0x60  0x6018                PUSH1 18        24 8
      0x05  0xf3  0xf3                  RETURN

  0x363d3d37363d34f0:
      0x00  0x36  0x36                  CALLDATASIZE    cds
      0x01  0x3d  0x3d                  RETURNDATASIZE  0 cds
      0x02  0x3d  0x3d                  RETURNDATASIZE  0 0 cds
      0x03  0x37  0x37                  CALLDATACOPY
      0x04  0x36  0x36                  CALLDATASIZE    cds
      0x05  0x3d  0x3d                  RETURNDATASIZE  0 cds
      0x06  0x34  0x34                  CALLVALUE       val 0 cds
      0x07  0xf0  0xf0                  CREATE          addr
  */
  
  bytes internal constant PROXY_CHILD_BYTECODE = hex"67_36_3d_3d_37_36_3d_34_f0_3d_52_60_08_60_18_f3";

  //                        KECCAK256_PROXY_CHILD_BYTECODE = keccak256(PROXY_CHILD_BYTECODE);
  bytes32 internal constant KECCAK256_PROXY_CHILD_BYTECODE = 0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f;

  /**
    @notice Returns the size of the code on a given address
    @param _addr Address that may or may not contain code
    @return size of the code on the given `_addr`
  */
  function codeSize(address _addr) internal view returns (uint256 size) {
    assembly { size := extcodesize(_addr) }
  }

  /**
    @notice Creates a new contract with given `_creationCode` and `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @param _creationCode Creation code (constructor) of the contract to be deployed, this value doesn't affect the resulting address
    @return addr of the deployed contract, reverts on error
  */
  function create3(bytes32 _salt, bytes memory _creationCode) internal returns (address addr) {
    return create3(_salt, _creationCode, 0);
  }

  /**
    @notice Creates a new contract with given `_creationCode` and `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @param _creationCode Creation code (constructor) of the contract to be deployed, this value doesn't affect the resulting address
    @param _value In WEI of ETH to be forwarded to child contract
    @return addr of the deployed contract, reverts on error
  */
  function create3(bytes32 _salt, bytes memory _creationCode, uint256 _value) internal returns (address addr) {
    // Creation code
    bytes memory creationCode = PROXY_CHILD_BYTECODE;

    // Get target final address
    addr = addressOf(_salt);
    if (codeSize(addr) != 0) revert TargetAlreadyExists();

    // Create CREATE2 proxy
    address proxy; assembly { proxy := create2(0, add(creationCode, 32), mload(creationCode), _salt)}
    if (proxy == address(0)) revert ErrorCreatingProxy();

    // Call proxy with final init code
    (bool success,) = proxy.call{ value: _value }(_creationCode);
    if (!success || codeSize(addr) == 0) revert ErrorCreatingContract();
  }

  /**
    @notice Computes the resulting address of a contract deployed using address(this) and the given `_salt`
    @param _salt Salt of the contract creation, resulting address will be derivated from this value only
    @return addr of the deployed contract, reverts on error

    @dev The address creation formula is: keccak256(rlp([keccak256(0xff ++ address(this) ++ _salt ++ keccak256(childBytecode))[12:], 0x01]))
  */
  function addressOf(bytes32 _salt) internal view returns (address) {
    address proxy = address(
      uint160(
        uint256(
          keccak256(
            abi.encodePacked(
              hex'ff',
              address(this),
              _salt,
              KECCAK256_PROXY_CHILD_BYTECODE
            )
          )
        )
      )
    );

    return address(
      uint160(
        uint256(
          keccak256(
            abi.encodePacked(
              hex"d6_94",
              proxy,
              hex"01"
            )
          )
        )
      )
    );
  }
}

@openzeppelin/contracts/utils/ReentrancyGuard.sol

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

@openzeppelin/contracts/token/ERC20/ERC20.sol

// 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/IERC20.sol

// 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/extensions/IERC20Metadata.sol

// 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/utils/Context.sol

// 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/interfaces/draft-IERC6093.sol

// 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);
}

Checking published source…