Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 135 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Approve | 20001950 | 81 days ago | IN | 0 ETH | 0.00009881 | ||||
Approve | 18730994 | 259 days ago | IN | 0 ETH | 0.00187206 | ||||
Mint | 18730979 | 259 days ago | IN | 0 ETH | 0.00325655 | ||||
Mint | 18728613 | 259 days ago | IN | 0 ETH | 0.00490772 | ||||
Approve | 18717213 | 261 days ago | IN | 0 ETH | 0.00297158 | ||||
Mint | 18717186 | 261 days ago | IN | 0 ETH | 0.00405108 | ||||
Approve | 18712176 | 261 days ago | IN | 0 ETH | 0.0018378 | ||||
Mint | 18712142 | 261 days ago | IN | 0 ETH | 0.00289458 | ||||
Mint | 18704010 | 263 days ago | IN | 0 ETH | 0.00220685 | ||||
Mint | 18689711 | 265 days ago | IN | 0 ETH | 0.00265859 | ||||
Approve | 18671933 | 267 days ago | IN | 0 ETH | 0.00381287 | ||||
Mint | 18671910 | 267 days ago | IN | 0 ETH | 0.00539163 | ||||
Mint | 18670940 | 267 days ago | IN | 0 ETH | 0.00381499 | ||||
Approve | 18652230 | 270 days ago | IN | 0 ETH | 0.00075127 | ||||
Mint | 18652222 | 270 days ago | IN | 0 ETH | 0.00148559 | ||||
Approve | 18648897 | 270 days ago | IN | 0 ETH | 0.00088587 | ||||
Mint | 18648891 | 270 days ago | IN | 0 ETH | 0.00153895 | ||||
Approve | 18642059 | 271 days ago | IN | 0 ETH | 0.00148613 | ||||
Mint | 18641623 | 271 days ago | IN | 0 ETH | 0.00228608 | ||||
Mint | 18641297 | 271 days ago | IN | 0 ETH | 0.00260966 | ||||
Approve | 18641287 | 271 days ago | IN | 0 ETH | 0.00154067 | ||||
Mint | 18641226 | 271 days ago | IN | 0 ETH | 0.00199765 | ||||
Approve | 18641198 | 271 days ago | IN | 0 ETH | 0.00135452 | ||||
Approve | 18638204 | 272 days ago | IN | 0 ETH | 0.0008425 | ||||
Mint | 18638198 | 272 days ago | IN | 0 ETH | 0.001473 |
Advanced mode: Intended for advanced users or developers and will display all Internal Transactions including zero value transfers. Name tag integration is not available in advanced view.
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block | From | To | ||||
---|---|---|---|---|---|---|---|
18730979 | 259 days ago | 0 ETH | |||||
18728613 | 259 days ago | 0 ETH | |||||
18717186 | 261 days ago | 0 ETH | |||||
18712142 | 261 days ago | 0 ETH | |||||
18704010 | 263 days ago | 0 ETH | |||||
18689711 | 265 days ago | 0 ETH | |||||
18671910 | 267 days ago | 0 ETH | |||||
18670940 | 267 days ago | 0 ETH | |||||
18652222 | 270 days ago | 0 ETH | |||||
18648891 | 270 days ago | 0 ETH | |||||
18641623 | 271 days ago | 0 ETH | |||||
18641391 | 271 days ago | 0 ETH | |||||
18641391 | 271 days ago | 0 ETH | |||||
18641391 | 271 days ago | 0 ETH | |||||
18641370 | 271 days ago | 0 ETH | |||||
18641356 | 271 days ago | 0 ETH | |||||
18641314 | 271 days ago | 0 ETH | |||||
18641314 | 271 days ago | 0 ETH | |||||
18641314 | 271 days ago | 0 ETH | |||||
18641297 | 271 days ago | 0 ETH | |||||
18641226 | 271 days ago | 0 ETH | |||||
18638198 | 272 days ago | 0 ETH | |||||
18633152 | 272 days ago | 0 ETH | |||||
18633152 | 272 days ago | 0 ETH | |||||
18633152 | 272 days ago | 0 ETH |
Loading...
Loading
Contract Name:
BLUE
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.19; import { ERC20 } from "solady/src/tokens/ERC20.sol"; contract BLUE is ERC20 { /*////////////////////////////////////////////////////////////// STATE VARIABLES //////////////////////////////////////////////////////////////*/ address public owner; mapping(address => bool) public alreadyClaimed; /*////////////////////////////////////////////////////////////// STRUCTS //////////////////////////////////////////////////////////////*/ struct Signature { uint8 v; bytes32 r; bytes32 s; } /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor() { owner = msg.sender; } /*////////////////////////////////////////////////////////////// MINT //////////////////////////////////////////////////////////////*/ function mint(Signature memory serverSignature) public { // |\__/,| (`\ // _.|o o |_ ) ) // -(((---(((-------- // | hi anon // | whether you're a searcher or protocol // | or a builder, do reach out to us! // | devs.aori.io // ------------------ // Check that the sender hasn't already claimed require(alreadyClaimed[msg.sender] != true, "Already claimed"); // Compute the sender hash bytes32 senderHash = keccak256( abi.encode( msg.sender, "BLUE" ) ); // Check that the server signature corresponds to the sender hash require( owner == ecrecover( keccak256( abi.encodePacked( "\x19Ethereum Signed Message:\n32", senderHash ) ), serverSignature.v, serverSignature.r, serverSignature.s ), "Server signature does not correspond to sender hash" ); // Let the sender claim their 1000 tokens alreadyClaimed[msg.sender] = true; _mint(msg.sender, 1000 ether); } /*////////////////////////////////////////////////////////////// VIEW FUNCTIONS //////////////////////////////////////////////////////////////*/ function name() public view virtual override returns (string memory) { return "BLUE"; } function symbol() public view virtual override returns (string memory) { return "BLUE"; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.4; /// @notice Simple ERC20 + EIP-2612 implementation. /// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol) /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol) /// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol) /// /// @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 use 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 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 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 {} }
{ "remappings": [ "@opensea/=node_modules/@opensea/", "ds-test/=lib/ds-test/src/", "forge-std/=lib/forge-std/src/", "solady/=lib/solady/" ], "optimizer": { "enabled": true, "runs": 1000000 }, "viaIR": true, "metadata": { "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "evmVersion": "paris", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"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":"","type":"address"}],"name":"alreadyClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct BLUE.Signature","name":"serverSignature","type":"tuple"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","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":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"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
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
119:2658:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;358:46;119:2658;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;7113:184:1;;;;;;;;;;119:2658:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;13703:24:1;13780:2752;;;;;;;;119:2658:0;13780:2752:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;119:2658:0;13780:2752:1;;;;;;;119:2658:0;13780:2752:1;;;;;;119:2658:0;13780:2752:1;;;;;;;;;;;;;119:2658:0;13780:2752:1;;;;;;;;;;;119:2658:0;13780:2752:1;;;119:2658:0;;13780:2752:1;;119:2658:0;;;13780:2752:1;;;119:2658:0;13780:2752:1;119:2658:0;13780:2752:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;119:2658:0;;13780:2752:1;;;;;;;;;;;;;;119:2658:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1499:10;119:2658;;;;;;;;;;;;;;1484:34;119:2658;;;;1628:76;;;1499:10;;119:2658;;;;;;;;;;;;;;;;;;1628:76;;119:2658;;;;;;;;;;;;;;;;;;1605:109;;119:2658;;;;;;;1887:134;;;;119:2658;;;;;;;;;1887:134;;119:2658;;;;;;;;;;;;;;;;;1856:183;;119:2658;;;;;;;;;;;;;;;;;;;;;;1829:329;;;119:2658;;;;;;;1829:329;;;;;;;119:2658;1820:338;119:2658;;1499:10;119:2658;;;;;;;;;;;;;;;17883:946:1;;;2358:10:0;;17883:946:1;;;;;;;;;;;;;;1499:10:0;17883:946:1;;;;;;;;;;;;;;;;;119:2658:0;17883:946:1;;;;119:2658:0;;17883:946:1;;;;119:2658:0;17883:946:1;119:2658:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1829:329;119:2658;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;8377:1143:1;;;;;;;119:2658:0;8377:1143:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;119:2658:0;;;;;8377:1143:1;;;;;;119:2658:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;12928:205:1;;;;;;;;;119:2658:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6679:148:1;;;;;;;;;119:2658:0;;;;;;;;;;;;;;;;;;;;;16960:346:1;119:2658:0;;:::i;:::-;;;;;;16883:24:1;16960:346;;;;;;;;;;;;;;;;;;;;;;;;;;119:2658:0;;;;;;;;;;;;;;;;;;;;;;5932:2:1;119:2658:0;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;10163:1922:1;119:2658:0;10163:1922:1;119:2658:0;;10163:1922:1;;;;;;;;;;;;;;;;119:2658:0;10163:1922:1;;;;119:2658:0;10163:1922:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;119:2658:0;10163:1922:1;;;;;;;119:2658:0;;;;;10163:1922:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;119:2658:0;;;;;;;;;;;;;;6407:68:1;;;119:2658:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;7567:413:1;;;;;;;;;;;;;;;;;;;;;;;;;;119:2658:0;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;119:2658:0;;;;;;;-1:-1:-1;119:2658:0;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;119:2658:0;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;
Swarm Source
ipfs://2a9f922ceb5bc182b1bf65ef126c82007aecd1119e46f0f0c6ed88f07cb33146
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.