Token

Sonic Peanuts (Snuts)

ERC-20

Overview

Max Total Supply

999,999,999,999 Snuts

Holders

574

Market

Price

Onchain Market Cap

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x157a0a8547287a81b69fa28ae941a86b2d5253b0

Filtered by Token Holder

0x9254A9026BddE2F7E6f590A43cdE1890cB792740

Balance

154,000,201.031789214261007239 Snuts

Value

$0.00

0x9254a9026bdde2f7e6f590a43cde1890cb792740

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:

Snuts

Compiler Version

v0.8.19+commit.7dd6d404

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at SonicScan.org on 2024-12-12
*/

// SPDX-License-Identifier: MIT

// File contracts/farm/tokens/ERC20.sol

// Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.4;

/// @dev Note:
/// - The ERC20 standard allows minting and transferring to and from the zero address,
///   minting and transferring zero tokens, as well as self-approvals.
///   For performance, this implementation WILL NOT revert for such actions.
///   Please add any checks with overrides if desired.
/// - The `permit` function uses the ecrecover precompile (0x1).
///
/// If you are overriding:
/// - NEVER violate the ERC20 invariant:
///   the total sum of all balances must be equal to `totalSupply()`.
/// - Check that the overridden function is actually used in the function you want to
///   change the behavior of. Much of the code has been manually inlined for performance.
abstract contract ERC20 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The total supply has overflowed.
    error TotalSupplyOverflow();

    /// @dev The allowance has overflowed.
    error AllowanceOverflow();

    /// @dev The allowance has underflowed.
    error AllowanceUnderflow();

    /// @dev Insufficient balance.
    error InsufficientBalance();

    /// @dev Insufficient allowance.
    error InsufficientAllowance();

    /// @dev The permit is invalid.
    error InvalidPermit();

    /// @dev The permit has expired.
    error PermitExpired();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.
    event Transfer(address indexed from, address indexed to, uint256 amount);

    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`.
    uint256 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    /// @dev `keccak256(bytes("Approval(address,address,uint256)"))`.
    uint256 private constant _APPROVAL_EVENT_SIGNATURE =
        0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The storage slot for the total supply.
    uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;

    /// @dev The balance slot of `owner` is given by:
    /// ```
    ///     mstore(0x0c, _BALANCE_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let balanceSlot := keccak256(0x0c, 0x20)
    /// ```
    uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;

    /// @dev The allowance slot of (`owner`, `spender`) is given by:
    /// ```
    ///     mstore(0x20, spender)
    ///     mstore(0x0c, _ALLOWANCE_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let allowanceSlot := keccak256(0x0c, 0x34)
    /// ```
    uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;

    /// @dev The nonce slot of `owner` is given by:
    /// ```
    ///     mstore(0x0c, _NONCES_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let nonceSlot := keccak256(0x0c, 0x20)
    /// ```
    uint256 private constant _NONCES_SLOT_SEED = 0x38377508;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev `(_NONCES_SLOT_SEED << 16) | 0x1901`.
    uint256 private constant _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX = 0x383775081901;

    /// @dev `keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")`.
    bytes32 private constant _DOMAIN_TYPEHASH =
        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;

    /// @dev `keccak256("1")`.
    bytes32 private constant _VERSION_HASH =
        0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;

    /// @dev `keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")`.
    bytes32 private constant _PERMIT_TYPEHASH =
        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ERC20 METADATA                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the name of the token.
    function name() public view virtual returns (string memory);

    /// @dev Returns the symbol of the token.
    function symbol() public view virtual returns (string memory);

    /// @dev Returns the decimals places of the token.
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           ERC20                            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the amount of tokens in existence.
    function totalSupply() public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_TOTAL_SUPPLY_SLOT)
        }
    }

    /// @dev Returns the amount of tokens owned by `owner`.
    function balanceOf(address owner) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.
    function allowance(address owner, address spender)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x34))
        }
    }

    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
    ///
    /// Emits a {Approval} event.
    function approve(address spender, uint256 amount) public virtual returns (bool) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and store the amount.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x34), amount)
            // Emit the {Approval} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))
        }
        return true;
    }

    /// @dev Transfer `amount` tokens from the caller to `to`.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    ///
    /// Emits a {Transfer} event.
    function transfer(address to, uint256 amount) public virtual returns (bool) {
        _beforeTokenTransfer(msg.sender, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, caller())
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(msg.sender, to, amount);
        return true;
    }

    /// @dev Transfers `amount` tokens from `from` to `to`.
    ///
    /// Note: Does not update the allowance if it is the maximum uint256 value.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.
    ///
    /// Emits a {Transfer} event.
    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
        _beforeTokenTransfer(from, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let from_ := shl(96, from)
            // Compute the allowance slot and load its value.
            mstore(0x20, caller())
            mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowance_ := sload(allowanceSlot)
            // If the allowance is not the maximum uint256 value.
            if add(allowance_, 1) {
                // Revert if the amount to be transferred exceeds the allowance.
                if gt(amount, allowance_) {
                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.
                    revert(0x1c, 0x04)
                }
                // Subtract and store the updated allowance.
                sstore(allowanceSlot, sub(allowance_, amount))
            }
            // Compute the balance slot and load its value.
            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(from, to, amount);
        return true;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          EIP-2612                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev For more performance, override to return the constant value
    /// of `keccak256(bytes(name()))` if `name()` will never change.
    function _constantNameHash() internal view virtual returns (bytes32 result) {}

    /// @dev Returns the current nonce for `owner`.
    /// This value is used to compute the signature for EIP-2612 permit.
    function nonces(address owner) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the nonce slot and load its value.
            mstore(0x0c, _NONCES_SLOT_SEED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /// @dev Sets `value` as the allowance of `spender` over the tokens of `owner`,
    /// authorized by a signed approval by `owner`.
    ///
    /// Emits a {Approval} event.
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        bytes32 nameHash = _constantNameHash();
        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.
        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));
        /// @solidity memory-safe-assembly
        assembly {
            // Revert if the block timestamp is greater than `deadline`.
            if gt(timestamp(), deadline) {
                mstore(0x00, 0x1a15a3cc) // `PermitExpired()`.
                revert(0x1c, 0x04)
            }
            let m := mload(0x40) // Grab the free memory pointer.
            // Clean the upper 96 bits.
            owner := shr(96, shl(96, owner))
            spender := shr(96, shl(96, spender))
            // Compute the nonce slot and load its value.
            mstore(0x0e, _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX)
            mstore(0x00, owner)
            let nonceSlot := keccak256(0x0c, 0x20)
            let nonceValue := sload(nonceSlot)
            // Prepare the domain separator.
            mstore(m, _DOMAIN_TYPEHASH)
            mstore(add(m, 0x20), nameHash)
            mstore(add(m, 0x40), _VERSION_HASH)
            mstore(add(m, 0x60), chainid())
            mstore(add(m, 0x80), address())
            mstore(0x2e, keccak256(m, 0xa0))
            // Prepare the struct hash.
            mstore(m, _PERMIT_TYPEHASH)
            mstore(add(m, 0x20), owner)
            mstore(add(m, 0x40), spender)
            mstore(add(m, 0x60), value)
            mstore(add(m, 0x80), nonceValue)
            mstore(add(m, 0xa0), deadline)
            mstore(0x4e, keccak256(m, 0xc0))
            // Prepare the ecrecover calldata.
            mstore(0x00, keccak256(0x2c, 0x42))
            mstore(0x20, and(0xff, v))
            mstore(0x40, r)
            mstore(0x60, s)
            let t := staticcall(gas(), 1, 0, 0x80, 0x20, 0x20)
            // If the ecrecover fails, the returndatasize will be 0x00,
            // `owner` will be checked if it equals the hash at 0x00,
            // which evaluates to false (i.e. 0), and we will revert.
            // If the ecrecover succeeds, the returndatasize will be 0x20,
            // `owner` will be compared against the returned address at 0x20.
            if iszero(eq(mload(returndatasize()), owner)) {
                mstore(0x00, 0xddafbaef) // `InvalidPermit()`.
                revert(0x1c, 0x04)
            }
            // Increment and store the updated nonce.
            sstore(nonceSlot, add(nonceValue, t)) // `t` is 1 if ecrecover succeeds.
            // Compute the allowance slot and store the value.
            // The `owner` is already at slot 0x20.
            mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))
            sstore(keccak256(0x2c, 0x34), value)
            // Emit the {Approval} event.
            log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)
            mstore(0x40, m) // Restore the free memory pointer.
            mstore(0x60, 0) // Restore the zero pointer.
        }
    }

    /// @dev Returns the EIP-712 domain separator for the EIP-2612 permit.
    function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {
        bytes32 nameHash = _constantNameHash();
        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.
        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Grab the free memory pointer.
            mstore(m, _DOMAIN_TYPEHASH)
            mstore(add(m, 0x20), nameHash)
            mstore(add(m, 0x40), _VERSION_HASH)
            mstore(add(m, 0x60), chainid())
            mstore(add(m, 0x80), address())
            result := keccak256(m, 0xa0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL MINT FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Mints `amount` tokens to `to`, increasing the total supply.
    ///
    /// Emits a {Transfer} event.
    function _mint(address to, uint256 amount) internal virtual {
        _beforeTokenTransfer(address(0), to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)
            let totalSupplyAfter := add(totalSupplyBefore, amount)
            // Revert if the total supply overflows.
            if lt(totalSupplyAfter, totalSupplyBefore) {
                mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.
                revert(0x1c, 0x04)
            }
            // Store the updated total supply.
            sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(address(0), to, amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL BURN FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Burns `amount` tokens from `from`, reducing the total supply.
    ///
    /// Emits a {Transfer} event.
    function _burn(address from, uint256 amount) internal virtual {
        _beforeTokenTransfer(from, address(0), amount);
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the balance slot and load its value.
            mstore(0x0c, _BALANCE_SLOT_SEED)
            mstore(0x00, from)
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Subtract and store the updated total supply.
            sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))
            // Emit the {Transfer} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)
        }
        _afterTokenTransfer(from, address(0), amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL TRANSFER FUNCTIONS                 */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Moves `amount` of tokens from `from` to `to`.
    function _transfer(address from, address to, uint256 amount) internal virtual {
        _beforeTokenTransfer(from, to, amount);
        /// @solidity memory-safe-assembly
        assembly {
            let from_ := shl(96, from)
            // Compute the balance slot and load its value.
            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))
            let fromBalanceSlot := keccak256(0x0c, 0x20)
            let fromBalance := sload(fromBalanceSlot)
            // Revert if insufficient balance.
            if gt(amount, fromBalance) {
                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                revert(0x1c, 0x04)
            }
            // Subtract and store the updated balance.
            sstore(fromBalanceSlot, sub(fromBalance, amount))
            // Compute the balance slot of `to`.
            mstore(0x00, to)
            let toBalanceSlot := keccak256(0x0c, 0x20)
            // Add and store the updated balance of `to`.
            // Will not overflow because the sum of all user balances
            // cannot exceed the maximum uint256 value.
            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))
            // Emit the {Transfer} event.
            mstore(0x20, amount)
            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))
        }
        _afterTokenTransfer(from, to, amount);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL ALLOWANCE FUNCTIONS                */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the allowance slot and load its value.
            mstore(0x20, spender)
            mstore(0x0c, _ALLOWANCE_SLOT_SEED)
            mstore(0x00, owner)
            let allowanceSlot := keccak256(0x0c, 0x34)
            let allowance_ := sload(allowanceSlot)
            // If the allowance is not the maximum uint256 value.
            if add(allowance_, 1) {
                // Revert if the amount to be transferred exceeds the allowance.
                if gt(amount, allowance_) {
                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.
                    revert(0x1c, 0x04)
                }
                // Subtract and store the updated allowance.
                sstore(allowanceSlot, sub(allowance_, amount))
            }
        }
    }

    /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.
    ///
    /// Emits a {Approval} event.
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            let owner_ := shl(96, owner)
            // Compute the allowance slot and store the amount.
            mstore(0x20, spender)
            mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))
            sstore(keccak256(0x0c, 0x34), amount)
            // Emit the {Approval} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     HOOKS TO OVERRIDE                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Hook that is called before any transfer of tokens.
    /// This includes minting and burning.
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /// @dev Hook that is called after any transfer of tokens.
    /// This includes minting and burning.
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}





// File contracts/token/snut/Snuts.sol

// Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.4;


contract Snuts is ERC20 {
    string internal _name;
    string internal _symbol;
    bytes32 internal immutable NAME_HASH;

    constructor(string memory name_, string memory symbol_, uint256 supply_, address receiver_) {
        _name = name_;
        _symbol = symbol_;

        NAME_HASH = keccak256(bytes(name_));
        _mint(receiver_, supply_);
    }

    function _constantNameHash() internal view virtual override returns (bytes32) {
        return NAME_HASH;
    }

    function decimals() public pure override returns (uint8) {
        return 18;
    }

    function name() public view override returns (string memory) {
        return _name;
    }

    function symbol() public view override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Burns a  token
     * @param account address to burn tokens from
     * @param amount amount of tokens to burn
     */
    function burn(address account, uint256 amount) external returns (bool) {
        if (account != msg.sender) {
            _spendAllowance(account, msg.sender, amount);
        }
        _burn(account, amount);
        return true;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint256","name":"supply_","type":"uint256"},{"internalType":"address","name":"receiver_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AllowanceOverflow","type":"error"},{"inputs":[],"name":"AllowanceUnderflow","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidPermit","type":"error"},{"inputs":[],"name":"PermitExpired","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","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":"amount","type":"uint256"}],"name":"Approval","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":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"result","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":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","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":"result","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":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","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":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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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)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000c9f2c9cd038943736989c0000000000000000000000000000da83f12fbb403b136dbb94f0c007b627d981c653000000000000000000000000000000000000000000000000000000000000000d536f6e6963205065616e757473000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005536e757473000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Sonic Peanuts
Arg [1] : symbol_ (string): Snuts
Arg [2] : supply_ (uint256): 999999999999000000000000000000
Arg [3] : receiver_ (address): 0xda83f12Fbb403b136DBb94f0C007B627d981C653

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 000000000000000000000000000000000000000c9f2c9cd038943736989c0000
Arg [3] : 000000000000000000000000da83f12fbb403b136dbb94f0c007b627d981c653
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000d
Arg [5] : 536f6e6963205065616e75747300000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 536e757473000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

25258:1185:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25850:92;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7302:586;;;;;;:::i;:::-;;:::i;:::-;;;1169:14:1;;1162:22;1144:41;;1132:2;1117:18;7302:586:0;1004:187:1;6118:200:0;6281:18;6275:25;6118:200;;;1342:25:1;;;1330:2;1315:18;6118:200:0;1196:177:1;9897:2235:0;;;;;;:::i;:::-;;:::i;25757:85::-;;;25832:2;1853:36:1;;1841:2;1826:18;25757:85:0;1711:184:1;16690:707:0;;;:::i;6387:293::-;;;;;;:::i;:::-;6558:18;6552:4;6545:32;;;6450:14;6591:19;;;;6656:4;6640:21;;6634:28;;6387:293;12784:348;;;;;;:::i;:::-;13011:17;13005:4;12998:31;;;12844:14;13043:19;;;;13108:4;13092:21;;13086:28;;12784:348;25950:96;;;:::i;26198:242::-;;;;;;:::i;:::-;;:::i;8083:1435::-;;;;;;:::i;:::-;;:::i;13322:3284::-;;;;;;:::i;:::-;;:::i;:::-;;6778:388;;;;;;:::i;:::-;7001:4;6994:21;7042:20;7036:4;7029:34;;;6894:14;7077:19;;;;7142:4;7126:21;;7120:28;;6778:388;25850:92;25896:13;25929:5;25922:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25850:92;:::o;7302:586::-;7376:4;7539:7;7533:4;7526:21;7574:20;7568:4;7561:34;7622:8;7616:4;7609:22;7675:6;7668:4;7662;7652:21;7645:37;7752:6;7746:4;7739:20;7841:4;7835:11;7831:2;7827:20;7817:8;7790:25;7784:4;7778;7773:75;-1:-1:-1;7876:4:0;7302:586;;;;:::o;9897:2235::-;9985:4;10140;10136:2;10132:13;10235:8;10229:4;10222:22;10281:20;10274:5;10271:31;10265:4;10258:45;10354:4;10348;10338:21;10397:13;10391:20;10511:1;10499:10;10495:18;10492:426;;;10629:10;10621:6;10618:22;10615:162;;;10677:10;10671:4;10664:24;10753:4;10747;10740:18;10615:162;10895:6;10883:10;10879:23;10864:13;10857:46;10492:426;;;11016:18;11009:5;11006:29;11000:4;10993:43;11089:4;11083;11073:21;11133:15;11127:22;11225:11;11217:6;11214:23;11211:149;;;11270:10;11264:4;11257:24;11340:4;11334;11327:18;11211:149;11471:6;11458:11;11454:24;11437:15;11430:49;;;11556:2;11550:4;11543:16;11610:4;11604;11594:21;11864:6;11848:13;11842:20;11838:33;11823:13;11816:56;;11942:6;11936:4;11929:20;12037:4;12031:11;12027:2;12023:20;12015:5;12011:2;12007:14;11980:25;11974:4;11968;11963:81;;-1:-1:-1;12120:4:0;9897:2235;;;;;:::o;16690:707::-;16747:14;25732:9;;16918:63;;16973:6;:4;:6::i;:::-;16957:24;;;;;;16946:35;;16918:63;17075:4;17069:11;17137:16;17134:1;17127:27;17189:8;17182:4;17179:1;17175:12;17168:30;17233:13;17226:4;17223:1;17219:12;17212:35;17282:9;17275:4;17272:1;17268:12;17261:31;17327:9;17320:4;17317:1;17313:12;17306:31;17374:4;17371:1;17361:18;17351:28;;;17045:345;16690:707;:::o;25950:96::-;25998:13;26031:7;26024:14;;;;;:::i;26198:242::-;26263:4;-1:-1:-1;;;;;26284:21:0;;26295:10;26284:21;26280:98;;26322:44;26338:7;26347:10;26359:6;26322:15;:44::i;:::-;26388:22;26394:7;26403:6;26388:5;:22::i;:::-;-1:-1:-1;26428:4:0;26198:242;;;;:::o;8083:1435::-;8153:4;8367:18;8361:4;8354:32;8413:8;8407:4;8400:22;8475:4;8469;8459:21;8519:15;8513:22;8611:11;8603:6;8600:23;8597:149;;;8656:10;8650:4;8643:24;8726:4;8720;8713:18;8597:149;8857:6;8844:11;8840:24;8823:15;8816:49;;;8942:2;8936:4;8929:16;8996:4;8990;8980:21;9250:6;9234:13;9228:20;9224:33;9209:13;9202:56;;9328:6;9322:4;9315:20;9417:4;9411:11;9407:2;9403:20;9393:8;9366:25;9360:4;9354;9349:75;9445:43;24824:91;13322:3284;25732:9;;13674:63;;13729:6;:4;:6::i;:::-;13713:24;;;;;;13702:35;;13674:63;13909:8;13896:11;13893:25;13890:145;;;13951:10;13945:4;13938:24;14015:4;14009;14002:18;13890:145;14064:4;14058:11;14182:5;14178:2;14174:14;14170:2;14166:23;14157:32;;14230:7;14226:2;14222:16;14218:2;14214:25;14203:36;;14325:39;14319:4;14312:53;14392:5;14386:4;14379:19;14445:4;14439;14429:21;14488:9;14482:16;14568;14565:1;14558:27;14620:8;14613:4;14610:1;14606:12;14599:30;14664:13;14657:4;14654:1;14650:12;14643:35;14713:9;14706:4;14703:1;14699:12;14692:31;14758:9;14751:4;14748:1;14744:12;14737:31;14808:4;14805:1;14795:18;14789:4;14782:32;14879:16;14876:1;14869:27;14931:5;14924:4;14921:1;14917:12;14910:27;14972:7;14965:4;14962:1;14958:12;14951:29;15015:5;15008:4;15005:1;15001:12;14994:27;15056:10;15049:4;15046:1;15042:12;15035:32;15102:8;15095:4;15092:1;15088:12;15081:30;15151:4;15148:1;15138:18;15132:4;15125:32;15248:4;15242;15232:21;15226:4;15219:35;15291:1;15285:4;15281:12;15275:4;15268:26;15321:1;15315:4;15308:15;15350:1;15344:4;15337:15;15411:4;15405;15399;15396:1;15393;15386:5;15375:41;15838:5;15819:16;15813:23;15810:34;15800:162;;15878:10;15872:4;15865:24;15942:4;15936;15929:18;15800:162;16049:18;16031:37;;-1:-1:-1;;;16247:43:0;;16241:4;16234:57;16328:4;16322;16312:21;16305:36;;;16282:7;16450:5;16423:25;-1:-1:-1;16410:4:0;16403:12;;16398:67;16486:4;16479:15;-1:-1:-1;;16557:1:0;16551:4;16544:15;-1:-1:-1;;;;;;13322:3284:0:o;22723:967::-;22968:7;22962:4;22955:21;23003:20;22997:4;22990:34;23051:5;23045:4;23038:19;23108:4;23102;23092:21;23151:13;23145:20;23265:1;23253:10;23249:18;23246:426;;;23383:10;23375:6;23372:22;23369:162;;;23431:10;23425:4;23418:24;23507:4;23501;23494:18;23369:162;23649:6;23637:10;23633:23;23618:13;23611:46;23246:426;;;22723:967;;;:::o;19421:1142::-;19693:18;19687:4;19680:32;19739:4;19733;19726:18;19797:4;19791;19781:21;19841:15;19835:22;19933:11;19925:6;19922:23;19919:149;;;19978:10;19972:4;19965:24;20048:4;20042;20035:18;19919:149;20162:24;;;20138:49;;20299:18;20293:25;;20289:38;;;20262:66;;-1:-1:-1;20385:20:0;;;-1:-1:-1;;;;;20463:22:0;;20436:25;20430:4;-1:-1:-1;20419:70:0;19421:1142;;:::o;14:548:1:-;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:173::-;635:20;;-1:-1:-1;;;;;684:31:1;;674:42;;664:70;;730:1;727;720:12;664:70;567:173;;;:::o;745:254::-;813:6;821;874:2;862:9;853:7;849:23;845:32;842:52;;;890:1;887;880:12;842:52;913:29;932:9;913:29;:::i;:::-;903:39;989:2;974:18;;;;961:32;;-1:-1:-1;;;745:254:1:o;1378:328::-;1455:6;1463;1471;1524:2;1512:9;1503:7;1499:23;1495:32;1492:52;;;1540:1;1537;1530:12;1492:52;1563:29;1582:9;1563:29;:::i;:::-;1553:39;;1611:38;1645:2;1634:9;1630:18;1611:38;:::i;:::-;1601:48;;1696:2;1685:9;1681:18;1668:32;1658:42;;1378:328;;;;;:::o;2082:186::-;2141:6;2194:2;2182:9;2173:7;2169:23;2165:32;2162:52;;;2210:1;2207;2200:12;2162:52;2233:29;2252:9;2233:29;:::i;:::-;2223:39;2082:186;-1:-1:-1;;;2082:186:1:o;2273:693::-;2384:6;2392;2400;2408;2416;2424;2432;2485:3;2473:9;2464:7;2460:23;2456:33;2453:53;;;2502:1;2499;2492:12;2453:53;2525:29;2544:9;2525:29;:::i;:::-;2515:39;;2573:38;2607:2;2596:9;2592:18;2573:38;:::i;:::-;2563:48;;2658:2;2647:9;2643:18;2630:32;2620:42;;2709:2;2698:9;2694:18;2681:32;2671:42;;2763:3;2752:9;2748:19;2735:33;2808:4;2801:5;2797:16;2790:5;2787:27;2777:55;;2828:1;2825;2818:12;2777:55;2273:693;;;;-1:-1:-1;2273:693:1;;;;2851:5;2903:3;2888:19;;2875:33;;-1:-1:-1;2955:3:1;2940:19;;;2927:33;;2273:693;-1:-1:-1;;2273:693:1:o;2971:260::-;3039:6;3047;3100:2;3088:9;3079:7;3075:23;3071:32;3068:52;;;3116:1;3113;3106:12;3068:52;3139:29;3158:9;3139:29;:::i;:::-;3129:39;;3187:38;3221:2;3210:9;3206:18;3187:38;:::i;:::-;3177:48;;2971:260;;;;;:::o;3236:380::-;3315:1;3311:12;;;;3358;;;3379:61;;3433:4;3425:6;3421:17;3411:27;;3379:61;3486:2;3478:6;3475:14;3455:18;3452:38;3449:161;;3532:10;3527:3;3523:20;3520:1;3513:31;3567:4;3564:1;3557:15;3595:4;3592:1;3585:15;3449:161;;3236:380;;;:::o

Swarm Source

ipfs://fae8e769543135dd1d9d5162fad0def01ce75b11ded24780e6a1dad98daf55d2

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.

Tools & Services