ETH Price: $3,482.25 (+0.53%)
Gas: 5.404 Gwei

Contract

0x4Bf46DCAEa00dCF615476d454afAbf2F0E750026
Sponsored
ads MoonPay
Buy, sell and swap Ethereum with MoonPay.Buy Now!

Spend less on fees, more on crypto. Buy crypto easily with MoonPay Balance. 20M+ users trust MoonPay worldwide.

ads MetaMask
Manage your web3 everything with MetaMask Portfolio. Try Now!

Ready to onboard to Ethereum? With MetaMask Portfolio, you're in control.

ads eToro
One-stop crypto shop: trusted, simple & safe.

Don’t invest unless you’re prepared to lose all the money you invest.

Sponsored
ads MetaMask
Meet MetaMask Portfolio - your key to getting more out of web3. Try Now

Ready to simplify your web3 experience? Try the all-in-one web3 app trusted by millions worldwide.

ads MetaMask
Swap directly on 9 networks Try Now

Available on 9 networks: Ethereum mainnet, Linea, Polygon, Optimism, BNB Chain, zkSync Era, Base, Avalanche.

Sponsored
ads Сoins.game
100 free spins for registration. Spin now!

Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!

ads BC.GAME
- The Best ETH Casino Claim Now!

5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.

ads Stake
200% Bonus, 100K Daily Giveaways, Instant Withdrawals Play Now!

Slots, Roulette, Poker & more - Proud sponsors of UFC, Everton & StakeF1 team!

Sponsored
ads BC.GAME
- The Best ETH Casino Claim Now!

5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.

ads CryptoSlots
Play & Get 25 Free Spins at CryptoSlots Play Now

Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!

ads CryptoWins
200% More Funds to Play on Us up to 4 BTC! Claim Now!

100s of games, generous bonuses, 20+ years of trusted gaming. Join CryptoWins & start winning today!

 
Source Code

Overview

ETH Balance

0 ETH

Eth Value

$0.00

More Info

Private Name Tags

Add

Multichain Info

$0 (Multichain Portfolio)
No addresses found
Advanced Filter

 Latest 4 from a total of 4 transactions

Transaction Hash
Method
Block
From
To
0x6b61a2ad6c6b7254bb138a3ebe6b40372677eb13d6d376e55d172db483add9ab
Decement201668882024-06-25 6:24:23183 days ago1719296663
ENS Namerobocups.eth
IN
0x4Bf46DCA...F0E750026
0 ETH0.000067412.54461005
0x14466b6f553102ea25898935b8127badb205c28521b5a3f2a50203389c3c6b68
Decement201668862024-06-25 6:23:59183 days ago1719296639
ENS Namerobocups.eth
IN
0x4Bf46DCA...F0E750026
0 ETH0.000062712.36713437
0xd70647583e1ce6e12c661a11df7a55c7323c003ba508d52c5dd2f3d485a8cd59
Decement201668842024-06-25 6:23:35183 days ago1719296615
ENS Namerobocups.eth
IN
0x4Bf46DCA...F0E750026
0 ETH0.000068172.57312564
0x1493555de0288fb2be30befc5c19c161e2d60dc04b494206ab4e0e832647131d
Increment201668822024-06-25 6:23:11183 days ago1719296591
ENS Namerobocups.eth
IN
0x4Bf46DCA...F0E750026
0 ETH0.000102062.34777452

Advanced mode:
Parent Transaction Hash Block
From
To
View All Internal Transactions
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Mytalent
Compiler Version
v0.8.24+commit.e11b9ed9
Optimization Enabled:
Yes with 200 runs
Other Settings:
london EvmVersion

Contract Source Code (Solidity Standard Json-Input format)

blockscan-logoblockscan-logoIDE
File 1 of 1 : HelloWorld.sol
// Deployed with the Atlas IDE
// https://app.atlaszk.com/
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.0;

contract Mytalent {
    uint256 public storedInteger;

    function increment() public {
        storedInteger += 1;
    }

    // SPDX-License-Identifier: MIT

    uint256 constant MAX_INT = type(uint256).max;

    function adder(uint256 _a, uint256 _b) external pure returns (uint256 sum, bool error) {
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);

        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
        if (_b > MAX_INT - _a) {
            return (0, true); // Overflow occurred
        }
        return (_a + _b, false);
    }

    function subtractor(uint256 _a, uint256 _b) external pure returns (uint256 difference, bool error) {
        if (_b > _a) {
            return (0, true); // Underflow occurred
        }
        return (_a - _b, false);
    }

    function decement() public {
        storedInteger = storedInteger + 27000;
        storedInteger -= 1;
    }
}

Settings
{
  "remappings": [
    "forge-std/=lib/forge-std/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "viaIR": false,
  "debug": {
    "revertStrings": "default"
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"_a","type":"uint256"},{"internalType":"uint256","name":"_b","type":"uint256"}],"name":"adder","outputs":[{"internalType":"uint256","name":"sum","type":"uint256"},{"internalType":"bool","name":"error","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"decement","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"increment","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"storedInteger","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_a","type":"uint256"},{"internalType":"uint256","name":"_b","type":"uint256"}],"name":"subtractor","outputs":[{"internalType":"uint256","name":"difference","type":"uint256"},{"internalType":"bool","name":"error","type":"bool"}],"stateMutability":"pure","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View
608060405234801561001057600080fd5b50610202806100206000396000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c806306b034e91461005c57806309b4a7db146100895780635270312a146100935780638203a0c3146100a6578063d09de08a146100bd575b600080fd5b61006f61006a366004610168565b6100c5565b604080519283529015156020830152015b60405180910390f35b61009161010a565b005b61006f6100a1366004610168565b610135565b6100af60005481565b604051908152602001610080565b610091610156565b6000806100d4846000196101a0565b8311156100e75750600090506001610103565b6100f183856101b9565b600091509150610103565b6000915091505b9250929050565b600054610119906169786101b9565b6000818155600191819061012e9084906101a0565b9091555050565b6000808383111561014c5750600090506001610103565b6100fc83856101a0565b600160008082825461012e91906101b9565b6000806040838503121561017b57600080fd5b50508035926020909101359150565b634e487b7160e01b600052601160045260246000fd5b818103818111156101b3576101b361018a565b92915050565b808201808211156101b3576101b361018a56fea264697066735822122054d86639f48acf03aeee0f577e2139a8328cccf3169575df43e6bdb99ac4e03a64736f6c63430008180033

Deployed Bytecode

0x608060405234801561001057600080fd5b50600436106100575760003560e01c806306b034e91461005c57806309b4a7db146100895780635270312a146100935780638203a0c3146100a6578063d09de08a146100bd575b600080fd5b61006f61006a366004610168565b6100c5565b604080519283529015156020830152015b60405180910390f35b61009161010a565b005b61006f6100a1366004610168565b610135565b6100af60005481565b604051908152602001610080565b610091610156565b6000806100d4846000196101a0565b8311156100e75750600090506001610103565b6100f183856101b9565b600091509150610103565b6000915091505b9250929050565b600054610119906169786101b9565b6000818155600191819061012e9084906101a0565b9091555050565b6000808383111561014c5750600090506001610103565b6100fc83856101a0565b600160008082825461012e91906101b9565b6000806040838503121561017b57600080fd5b50508035926020909101359150565b634e487b7160e01b600052601160045260246000fd5b818103818111156101b3576101b361018a565b92915050565b808201808211156101b3576101b361018a56fea264697066735822122054d86639f48acf03aeee0f577e2139a8328cccf3169575df43e6bdb99ac4e03a64736f6c63430008180033

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
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.