S Price: $0.517538 (+0.79%)
    /

    Token

    Shadow (SHADOW)

    Overview

    Max Total Supply

    3,235,831.91 SHADOW

    Holders

    1,769 (0.00%)
    Created with Highcharts 10.2.1

    Market

    Price

    $36.83 @ 71.163858 S (-9.51%)

    Onchain Market Cap

    $119,175,689.25

    Circulating Supply Market Cap

    $7,167,892.00

    Other Info

    Token Contract (WITH 18 Decimals)

    Balance
    0.000000747490215665 SHADOW

    Value
    $0.00 ( ~0 S) [0.0000%]
    0xA92a218E46b63C9e1A0A7d3fF1090D10Ae005e03
    Loading...
    Loading
    Loading...
    Loading
    Loading...
    Loading

    OVERVIEW

    A Sonic-native concentrated liquidity exchange.The ultimate trading hub on Sonic.

    Contract Source Code Verified (Exact Match)

    Contract Name:
    Shadow

    Compiler Version
    v0.8.28+commit.7893614a

    Optimization Enabled:
    Yes with 1633 runs

    Other Settings:
    cancun EvmVersion
    File 1 of 21 : Shadow.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.26;
    import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
    import {ERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
    /// @title EmissionsToken contract for Shadow
    /// @dev standard mintable ERC20 built for vote-governance emissions
    contract Shadow is ERC20, ERC20Burnable, ERC20Permit {
    error NOT_MINTER();
    /// @notice minter contract address
    address public minter;
    constructor(
    address _minter
    ) ERC20("Shadow", "SHADOW") ERC20Permit("Shadow") {
    minter = _minter;
    }
    /// @notice mint function called by minter weekly
    /// @param to the address to mint to
    /// @param amount amount of tokens
    function mint(address to, uint256 amount) public {
    require(msg.sender == minter, NOT_MINTER());
    _mint(to, amount);
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 2 of 21 : ERC20.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.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
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 3 of 21 : ERC20Burnable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // 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.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 4 of 21 : ERC20Permit.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/ERC20Permit.sol)
    pragma solidity ^0.8.20;
    import {IERC20Permit} from "./IERC20Permit.sol";
    import {ERC20} from "../ERC20.sol";
    import {ECDSA} from "../../../utils/cryptography/ECDSA.sol";
    import {EIP712} from "../../../utils/cryptography/EIP712.sol";
    import {Nonces} from "../../../utils/Nonces.sol";
    /**
    * @dev Implementation of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in
    * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].
    *
    * Adds the {permit} method, which can be used to change an account's ERC-20 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.
    */
    abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces {
    bytes32 private constant PERMIT_TYPEHASH =
    keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    /**
    * @dev Permit deadline has expired.
    */
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 5 of 21 : IERC20.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
    pragma solidity ^0.8.20;
    /**
    * @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.
    */
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 6 of 21 : IERC20Metadata.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)
    pragma solidity ^0.8.20;
    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);
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 7 of 21 : Context.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // 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;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 8 of 21 : draft-IERC6093.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
    pragma solidity ^0.8.20;
    /**
    * @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.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 9 of 21 : IERC20Permit.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in
    * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].
    *
    * Adds the {permit} method, which can be used to change an account's ERC-20 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);
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 10 of 21 : ECDSA.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/ECDSA.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
    *
    * These functions can be used to verify that a message was signed by the holder
    * of the private keys of a given address.
    */
    library ECDSA {
    enum RecoverError {
    NoError,
    InvalidSignature,
    InvalidSignatureLength,
    InvalidSignatureS
    }
    /**
    * @dev The signature derives the `address(0)`.
    */
    error ECDSAInvalidSignature();
    /**
    * @dev The signature has an invalid length.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 11 of 21 : EIP712.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/EIP712.sol)
    pragma solidity ^0.8.20;
    import {MessageHashUtils} from "./MessageHashUtils.sol";
    import {ShortStrings, ShortString} from "../ShortStrings.sol";
    import {IERC5267} from "../../interfaces/IERC5267.sol";
    /**
    * @dev https://eips.ethereum.org/EIPS/eip-712[EIP-712] is a standard for hashing and signing of typed structured data.
    *
    * The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
    * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
    * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
    * produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
    *
    * This contract implements the EIP-712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
    * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
    * ({_hashTypedDataV4}).
    *
    * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
    * the chain id to protect against replay attacks on an eventual fork of the chain.
    *
    * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
    * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 12 of 21 : Nonces.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev Provides tracking nonces for addresses. Nonces will only increment.
    */
    abstract contract Nonces {
    /**
    * @dev The nonce used for an `account` is not the expected current nonce.
    */
    error InvalidAccountNonce(address account, uint256 currentNonce);
    mapping(address account => uint256) private _nonces;
    /**
    * @dev Returns the next unused nonce for an address.
    */
    function nonces(address owner) public view virtual returns (uint256) {
    return _nonces[owner];
    }
    /**
    * @dev Consumes a nonce.
    *
    * Returns the current value and increments nonce.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 13 of 21 : MessageHashUtils.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/MessageHashUtils.sol)
    pragma solidity ^0.8.20;
    import {Strings} from "../Strings.sol";
    /**
    * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
    *
    * The library provides methods for generating a hash of a message that conforms to the
    * https://eips.ethereum.org/EIPS/eip-191[ERC-191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
    * specifications.
    */
    library MessageHashUtils {
    /**
    * @dev Returns the keccak256 digest of an ERC-191 signed data with version
    * `0x45` (`personal_sign` messages).
    *
    * The digest is calculated by prefixing a bytes32 `messageHash` with
    * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
    * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
    *
    * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
    * keccak256, although any bytes32 value can be safely used because the final digest will
    * be re-hashed.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 14 of 21 : ShortStrings.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/ShortStrings.sol)
    pragma solidity ^0.8.20;
    import {StorageSlot} from "./StorageSlot.sol";
    // | string | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |
    // | length | 0x BB |
    type ShortString is bytes32;
    /**
    * @dev This library provides functions to convert short memory strings
    * into a `ShortString` type that can be used as an immutable variable.
    *
    * Strings of arbitrary length can be optimized using this library if
    * they are short enough (up to 31 bytes) by packing them with their
    * length (1 byte) in a single EVM word (32 bytes). Additionally, a
    * fallback mechanism can be used for every other case.
    *
    * Usage example:
    *
    * ```solidity
    * contract Named {
    * using ShortStrings for *;
    *
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 15 of 21 : IERC5267.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)
    pragma solidity ^0.8.20;
    interface IERC5267 {
    /**
    * @dev MAY be emitted to signal that the domain could have changed.
    */
    event EIP712DomainChanged();
    /**
    * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
    * signature.
    */
    function eip712Domain()
    external
    view
    returns (
    bytes1 fields,
    string memory name,
    string memory version,
    uint256 chainId,
    address verifyingContract,
    bytes32 salt,
    uint256[] memory extensions
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 16 of 21 : Strings.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/Strings.sol)
    pragma solidity ^0.8.20;
    import {Math} from "./math/Math.sol";
    import {SignedMath} from "./math/SignedMath.sol";
    /**
    * @dev String operations.
    */
    library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;
    /**
    * @dev The `value` string doesn't fit in the specified `length`.
    */
    error StringsInsufficientHexLength(uint256 value, uint256 length);
    /**
    * @dev Converts a `uint256` to its ASCII `string` decimal representation.
    */
    function toString(uint256 value) internal pure returns (string memory) {
    unchecked {
    uint256 length = Math.log10(value) + 1;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 17 of 21 : StorageSlot.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
    // This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
    pragma solidity ^0.8.20;
    /**
    * @dev Library for reading and writing primitive types to specific storage slots.
    *
    * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
    * This library helps with reading and writing to such slots without the need for inline assembly.
    *
    * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
    *
    * Example usage to set ERC-1967 implementation slot:
    * ```solidity
    * contract ERC1967 {
    * // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
    * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    *
    * function _getImplementation() internal view returns (address) {
    * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    * }
    *
    * function _setImplementation(address newImplementation) internal {
    * require(newImplementation.code.length > 0);
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 18 of 21 : Math.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)
    pragma solidity ^0.8.20;
    import {Panic} from "../Panic.sol";
    import {SafeCast} from "./SafeCast.sol";
    /**
    * @dev Standard math utilities missing in the Solidity language.
    */
    library Math {
    enum Rounding {
    Floor, // Toward negative infinity
    Ceil, // Toward positive infinity
    Trunc, // Toward zero
    Expand // Away from zero
    }
    /**
    * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
    */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
    unchecked {
    uint256 c = a + b;
    if (c < a) return (false, 0);
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 19 of 21 : SignedMath.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol)
    pragma solidity ^0.8.20;
    import {SafeCast} from "./SafeCast.sol";
    /**
    * @dev Standard signed math utilities missing in the Solidity language.
    */
    library SignedMath {
    /**
    * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
    *
    * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
    * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
    * one branch when needed, making this function more expensive.
    */
    function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) {
    unchecked {
    // branchless ternary works because:
    // b ^ (a ^ b) == a
    // b ^ 0 == b
    return b ^ ((a ^ b) * int256(SafeCast.toUint(condition)));
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 20 of 21 : Panic.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)
    pragma solidity ^0.8.20;
    /**
    * @dev Helper library for emitting standardized panic codes.
    *
    * ```solidity
    * contract Example {
    * using Panic for uint256;
    *
    * // Use any of the declared internal constants
    * function foo() { Panic.GENERIC.panic(); }
    *
    * // Alternatively
    * function foo() { Panic.panic(Panic.GENERIC); }
    * }
    * ```
    *
    * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
    *
    * _Available since v5.1._
    */
    // slither-disable-next-line unused-state
    library Panic {
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 21 of 21 : SafeCast.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
    // This file was procedurally generated from scripts/generate/templates/SafeCast.js.
    pragma solidity ^0.8.20;
    /**
    * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
    * checks.
    *
    * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
    * easily result in undesired exploitation or bugs, since developers usually
    * assume that overflows raise errors. `SafeCast` restores this intuition by
    * reverting the transaction when such an operation overflows.
    *
    * Using this library instead of the unchecked operations eliminates an entire
    * class of bugs, so it's recommended to use it always.
    */
    library SafeCast {
    /**
    * @dev Value doesn't fit in an uint of `bits` size.
    */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
    /**
    * @dev An int value doesn't fit in an uint of `bits` size.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Settings
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    {
    "remappings": [
    "@openzeppelin-contracts-5.1.0/=dependencies/@openzeppelin-contracts-5.1.0/",
    "@openzeppelin-contracts-upgradeable-5.1.0/=dependencies/@openzeppelin-contracts-upgradeable-5.1.0/",
    "@forge-std-1.9.4/=dependencies/forge-std-1.9.4/",
    "@layerzerolabs/=node_modules/@layerzerolabs/",
    "@layerzerolabs/lz-evm-protocol-v2/=node_modules/@layerzerolabs/lz-evm-protocol-v2/",
    "@openzeppelin-contracts-upgradeable/=dependencies/@openzeppelin-contracts-upgradeable-5.1.0/",
    "@openzeppelin-contracts/contracts/=dependencies/@openzeppelin-contracts-5.1.0/",
    "@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.1.0/",
    "erc4626-tests/=dependencies/erc4626-property-tests-1.0/",
    "forge-std/=dependencies/forge-std-1.9.4/src/",
    "permit2/=lib/permit2/",
    "@openzeppelin-3.4.2/=node_modules/@openzeppelin-3.4.2/",
    "@openzeppelin-contracts-5.1.0/=dependencies/@openzeppelin-contracts-5.1.0/",
    "@openzeppelin-contracts-upgradeable-5.1.0/=dependencies/@openzeppelin-contracts-upgradeable-5.1.0/",
    "@uniswap/=node_modules/@uniswap/",
    "base64-sol/=node_modules/base64-sol/",
    "ds-test/=node_modules/ds-test/",
    "erc4626-property-tests-1.0/=dependencies/erc4626-property-tests-1.0/",
    "eth-gas-reporter/=node_modules/eth-gas-reporter/",
    "forge-std-1.9.4/=dependencies/forge-std-1.9.4/src/",
    "hardhat/=node_modules/hardhat/",
    "solidity-bytes-utils/=node_modules/solidity-bytes-utils/",
    "solmate/=node_modules/solmate/"
    ],
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Contract Security Audit

    Contract ABI

    [{"inputs":[{"internalType":"address","name":"_minter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"ERC2612ExpiredSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC2612InvalidSigner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"currentNonce","type":"uint256"}],"name":"InvalidAccountNonce","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[],"name":"NOT_MINTER","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

    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

    Deployed Bytecode

    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

    Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

    000000000000000000000000c7022f359cd1bda8ab8a19d1f19d769cbf7f3765

    -----Decoded View---------------
    Arg [0] : _minter (address): 0xc7022F359cD1bDa8aB8a19d1F19d769cbf7F3765

    -----Encoded View---------------
    1 Constructor Arguments found :
    Arg [0] : 000000000000000000000000c7022f359cd1bda8ab8a19d1f19d769cbf7f3765


    [ Download: CSV Export  ]
    [ Download: CSV Export  ]

    A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.