Contract Address 0xea8DfeBBd4DB9E93513b7d797adF14b7b3e15edb

 

Overview

Total Supply:
1,000,000,000 MDR

Circulating Supply:
300,000,000 MDR

Holders:
Addresses

Price:
$0.07

Market Cap/Fully MC:
$400,000,000 (@ $0.07)

Token:
My Name Tag:
Not Available, login to update

Contract:
0xea8DfeBBd4DB9E93513b7d797adF14b7b3e15edb

Creator:
0x44B87A2a404DA6393e16b2e69aC86A40d4EF474c

Decimal:
8

Issuing Time :
2023-05-04 11:23

Official Website:
#

Social Profiles:
Balance
0 MDR

Value
$0.00

Txn Hash
Method
Age
From
To
Quantity
0x60457a198fe0ab2b24fbf549cc97b7226c6631ae5ccc2b2383d258021f9c016e Transfer 2025-04-02 14:19:40 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c OUT 0x742d3dbc6adc1f9fe685c15c6d49405957244923 109,872.1000 MDR
0x8b8de6e2b9b8e864aee9055cbb83be15c2e7bd4d1fa20d7352bdfe4e7e2da71c Transfer 2025-03-30 13:06:07 0x25a5119513127de5e8f531715ca31685cb103615 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 1,421.0000 MDR
0x584d1eb0b9953b9bb9e46d7517ecd384ecd8ccd7fdd8abf49a3bab9fd4e7a94a Transfer 2025-03-30 13:04:13 0x33cf6c591b37302e4b51f12721bbf31dca376c1e IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 1,141.0000 MDR
0xfb08a3d9b86753ad10077a8fc33624f89850b796e7038fd4c29376f542ff8651 Transfer 2025-03-30 13:02:55 0xfa57c6f64681d680994eb2544d6c9736e6adf598 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 29,264.0000 MDR
0x436c1191a7e2487f6d48c288c6441262fe4e86236fa1be7235786fd0741e835e Transfer 2025-03-30 13:01:55 0xc4f4868219270a6b60adc16d6210d8497b983c1b IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 2,515.9000 MDR
0xc045e241ec8dc71681a103bfda35909e632800d85491f559346da39c75e73e2f Transfer 2025-03-30 13:00:49 0x10b9442ff0ca74b17f72c7e6593f405b2d571fef IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 20,255.0000 MDR
0xd9d2c965140b9971eeb6296cbf6f7aa6ec9d7db2074894e0cebe7bc1cc83bdaf Transfer 2025-03-30 12:42:55 0x49c25c04aeb025e7f0c519b1bff06d5aa7e72fba IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 5,872.0000 MDR
0x45dce876c2c67212d6b9d8e6819873dd521d729ab0ee72f95fb152f521aa6e51 Transfer 2025-03-30 11:19:37 0x214f5b8b940bc15b32c77d157b3db36fa2d6ef44 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 3,325.0000 MDR
0x9895cb448ba00c795deb7da37f035d8e621d57a47906c5c6c6170df6be1eece5 Transfer 2025-03-30 11:19:04 0x251e1d98743879f0695e482db462413f3025d6cb IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 3,325.0000 MDR
0xe71accfac781d5cfa320a43d0ceff2cee3504cb7c972ca93ffa0b74f7c1cb9f3 Transfer 2025-03-30 10:13:40 0x51c0ae58cc6feff313490824d04ed83c96bd61b6 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 9,618.4000 MDR
0xec10de4a0ec93798021351dfeed329a00cbd1f59b49b81a709b563ba143b9985 Transfer 2025-03-30 10:13:10 0x5c42d8cab6c2287e6d9516f8b6fdebcb4d0a9908 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 8,450.2500 MDR
0x4eaec824a01e18b4ef31225b80bd9d1d845f6ebdf0348ca5b8cf8793422b718b Transfer 2025-03-30 10:12:22 0x1264a04cc490c26ae286b7805d07f2c0b5a62652 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 1,801.1500 MDR
0xd795540949a6841c19039b9c7108badd93e8f5fb827966cc872ef497252ab83f Transfer 2025-03-30 10:10:37 0xb4ab91e17075e19759d92fd7154271922ade5ce0 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 144.3000 MDR
0x720fa6559e3507b1eed812ed059ef8cbac69b7f02811f91b9d3e88c2a5ccc9db Transfer 2025-03-30 10:05:10 0x47ba15ada4f27de07dc194f0349e2cbdc960bc95 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 1,270.6500 MDR
0x99e95cfc3ae9f3b81af090540ed4b1056748a732d5d343f1aad2115669d461de Transfer 2025-03-25 18:42:52 0xb0c1cdaa544f4bca12b83bcd115f0e3b9e78bb78 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 8,517.0000 MDR
0x5fa90d82c78d877b2dc6b43a4367fda6232f1bdbed13b47308274eac025fac40 Transfer 2025-01-25 12:37:21 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c OUT 0xfeb124859bd66aede071caa570a21b0ec88472fc 30,000.0000 MDR
0x18c4aa2fa3033994205ebc8e5c161eae09c8016b95c6015b13099f829f965a2a Transfer 2025-01-12 10:52:11 0x49c25c04aeb025e7f0c519b1bff06d5aa7e72fba IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 26,951.3000 MDR
0xd8cbe3eeb04d5a52af433f90c8e012e5676fb86b1ec2ebefec65781d5505f00f Transfer 2025-01-10 15:18:08 0x49c25c04aeb025e7f0c519b1bff06d5aa7e72fba IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 5,718.0000 MDR
0x0657ddc71c31ab55e04708d61c3f3ad5bee54f1812ec4d0b86be37ea8535306c Transfer 2024-08-23 16:25:32 0x20133264da3139b659df04cbf889b98864c7cb66 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 600.4000 MDR
0x8564e2d7b2840b04ea60e816658c4f3ff595ca122410e7b4dc1b64d862e42506 Transfer 2024-07-20 13:42:31 0x20133264da3139b659df04cbf889b98864c7cb66 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 544.3500 MDR
0xe428b14a9fec305c627eca2797aa0113d5d5a90300d4322db5e8cab219db17af Transfer 2024-07-03 12:25:33 0x20133264da3139b659df04cbf889b98864c7cb66 IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 1,578.9000 MDR
0x2f594b5daa1213e56d31f907f531f1cfd16b7d90eb3f65f6b05e61f772b2444e Transfer 2024-06-27 22:13:08 0x44b87a2a404da6393e16b2e69ac86a40d4ef474c IN 0xde9d40ccfd2469fc75871cac0e97cea1e0a3f59c 7,558.5000 MDR

 Latest 9 ERC-20 Token Transfer Events

Txn Hash
Block
From
To
Value [Txn Fee]
0x4c8599fa5db502d29d78ad3c85e39ff7160c4775e4e645cd344af13d662eded3 16807914 2 hrs 6 mins ago 0x931cdb4f83672a7803a552414c026b7914bb72ae OUT 0x1fd1259fa8cdc60c6e8c86cfa592ca1b8403dfad 0 BLN 0.000143891192

 Latest 25 blocks (From a total of 353,417 blocks with 47,300.41 BLN in fees)

Block Transaction Gas Used Reward
16738610 31 secs ago 430 19,977,660 (99.89%)
0.16001155598032753 BLN
16738609 33 secs ago 349 19,967,071 (99.84%)
1.368512730518157196 BLN
16738608 35 secs ago 430 19,959,026 (99.80%)
1.119899900678144967 BLN

pragma solidity ^0.4.24;

contract ERC20 {
    uint256 public totalSupply;

    function balanceOf(address who) public view returns (uint256 balance);

    function allowance(address owner, address spender) public view returns (uint256 remaining);

    function transfer(address to, uint256 value) public returns (bool success);

    function approve(address spender, uint256 value) public returns (bool success);

    function transferFrom(address from, address to, uint256 value) public returns (bool success);

    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

library SafeMath {
    function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
        c = a - b;
        assert(b <= a && c <= a);
        return c;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
        c = a + b;
        assert(c >= a && c>=b);
        return c;
    }
}

library SafeERC20 {
    function safeTransfer(ERC20 _token, address _to, uint256 _value) internal {
        require(_token.transfer(_to, _value));
    }
}

contract Owned {
    address public owner;

    constructor() public {
        owner = msg.sender;
    }

    modifier onlyOwner {
        require(msg.sender == owner,"O1- Owner only function");
        _;
    }

    function setOwner(address newOwner) onlyOwner public {
        owner = newOwner;
    }
}

contract Pausable is Owned {
    event Pause();
    event Unpause();

    bool public paused = false;

    modifier whenNotPaused() {
        require(!paused);
        _;
    }

    modifier whenPaused() {
        require(paused);
        _;
    }

    function pause() public onlyOwner whenNotPaused {
        paused = true;
        emit Pause();
    }

    function unpause() public onlyOwner whenPaused {
        paused = false;
        emit Unpause();
    }
}

contract AVNrich is Owned, Pausable, ERC20 {
    using SafeMath for uint256;
    using SafeERC20 for ERC20;

    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowed;
    mapping (address => bool) public frozenAccount;
    mapping (address => bool) public verifyPublisher;
    mapping (address => bool) public verifyWallet;

    struct fStruct { uint256 index; }
    mapping(string => fStruct) private fileHashes;
    string[] private fileIndex;

    string public constant name = "Bullion Share";
    uint8 public constant decimals = 8;
    string public constant symbol = "BLNS";
    uint256 public constant initialSupply = 21000000;
    uint256 public validationPrice = 7 * 10 ** uint(decimals);
    address public validationWallet = address(0);

    constructor() public {
        validationWallet = msg.sender;
        verifyWallet[msg.sender] = true;
        totalSupply = initialSupply * 10 ** uint(decimals);
        balances[msg.sender] = totalSupply;
        emit Transfer(address(0),owner,initialSupply);
    }

    function () public payable {
        revert();
    }

    function transfer(address _to, uint256 _value) public whenNotPaused returns (bool success) {
        require(_to != msg.sender,"T1- Recipient can not be the same as sender");
        require(_to != address(0),"T2- Please check the recipient address");
        require(balances[msg.sender] >= _value,"T3- The balance of sender is too low");
        require(!frozenAccount[msg.sender],"T4- The wallet of sender is frozen");
        require(!frozenAccount[_to],"T5- The wallet of recipient is frozen");

        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);

        emit Transfer(msg.sender, _to, _value);

        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool success) {
        require(_to != address(0),"TF1- Please check the recipient address");
        require(balances[_from] >= _value,"TF2- The balance of sender is too low");
        require(allowed[_from][msg.sender] >= _value,"TF3- The allowance of sender is too low");
        require(!frozenAccount[_from],"TF4- The wallet of sender is frozen");
        require(!frozenAccount[_to],"TF5- The wallet of recipient is frozen");

        balances[_from] = balances[_from].sub(_value);
        balances[_to] = balances[_to].add(_value);

        allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);

        emit Transfer(_from, _to, _value);

        return true;
    }

    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) public whenNotPaused returns (bool success) {
        require((_value == 0) || (allowed[msg.sender][_spender] == 0),"A1- Reset allowance to 0 first");

        allowed[msg.sender][_spender] = _value;

        emit Approval(msg.sender, _spender, _value);

        return true;
    }

    function increaseApproval(address _spender, uint256 _addedValue) public whenNotPaused returns (bool) {
        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);

        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);

        return true;
    }

    function decreaseApproval(address _spender, uint256 _subtractedValue) public whenNotPaused returns (bool) {
        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].sub(_subtractedValue);

        emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);

        return true;
    }

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }

    struct TKN { address sender; uint256 value; bytes data; bytes4 sig; }

    function tokenFallback(address _from, uint256 _value, bytes _data) public pure returns (bool) {
        TKN memory tkn;
        tkn.sender = _from;
        tkn.value = _value;
        tkn.data = _data;
        uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
        tkn.sig = bytes4(u);
        return true;
    }

    function transferToken(address tokenAddress, uint256 tokens) public onlyOwner {
        ERC20(tokenAddress).safeTransfer(owner,tokens);
    }

    function burn(uint256 _value) public onlyOwner returns (bool) {
        require(_value <= balances[msg.sender],"B1- The balance of burner is too low");

        balances[msg.sender] = balances[msg.sender].sub(_value);
        totalSupply = totalSupply.sub(_value);

        emit Burn(msg.sender, _value);

        emit Transfer(msg.sender, address(0), _value);

        return true;
    }

    function freeze(address _address, bool _state) public onlyOwner returns (bool) {
        frozenAccount[_address] = _state;

        emit Freeze(_address, _state);

        return true;
    }

    function validatePublisher(address Address, bool State, string Publisher) public onlyOwner returns (bool) {
        verifyPublisher[Address] = State;

        emit ValidatePublisher(Address,State,Publisher);

        return true;
    }

    function validateWallet(address Address, bool State, string Wallet) public onlyOwner returns (bool) {
        verifyWallet[Address] = State;

        emit ValidateWallet(Address,State,Wallet);

        return true;
    }

    function validateFile(address To, uint256 Payment, bytes Data, bool cStore, bool eLog) public whenNotPaused returns (bool) {
        require(Payment>=validationPrice,"V1- Insufficient payment provided");
        require(verifyPublisher[msg.sender],"V2- Unverified publisher address");
        require(!frozenAccount[msg.sender],"V3- The wallet of publisher is frozen");
        require(Data.length == 64,"V4- Invalid hash provided");

        if (!verifyWallet[To] || frozenAccount[To]) {
            To = validationWallet;
        }

        uint256 index = 0;
        string memory fileHash = string(Data);

        if (cStore) {
            if (fileIndex.length > 0) {
                require(fileHashes[fileHash].index == 0,"V5- This hash was previously validated");
            }

            fileHashes[fileHash].index = fileIndex.push(fileHash)-1;
            index = fileHashes[fileHash].index;
        }

        if (allowed[To][msg.sender] >= Payment) {
            allowed[To][msg.sender] = allowed[To][msg.sender].sub(Payment);
        } else {
            balances[msg.sender] = balances[msg.sender].sub(Payment);
            balances[To] = balances[To].add(Payment);
        }

        emit Transfer(msg.sender, To, Payment);

        if (eLog) {
            emit ValidateFile(index,fileHash);
        }

        return true;
    }

    function verifyFile(string fileHash) public view returns (bool) {
        if (fileIndex.length == 0) {
            return false;
        }

        bytes memory a = bytes(fileIndex[fileHashes[fileHash].index]);
        bytes memory b = bytes(fileHash);

        if (a.length != b.length) {
            return false;
        }

        for (uint256 i = 0; i < a.length; i ++) {
            if (a[i] != b[i]) {
                return false;
            }
        }

        return true;
    }

    function setPrice(uint256 newPrice) public onlyOwner {
        validationPrice = newPrice;
    }

    function setWallet(address newWallet) public onlyOwner {
        validationWallet = newWallet;
    }

    function listFiles(uint256 startAt, uint256 stopAt) onlyOwner public returns (bool) {
        if (fileIndex.length == 0) {
            return false;
        }

        require(startAt <= fileIndex.length-1,"L1- Please select a valid start");

        if (stopAt > 0) {
            require(stopAt > startAt && stopAt <= fileIndex.length-1,"L2- Please select a valid stop");
        } else {
            stopAt = fileIndex.length-1;
        }

        for (uint256 i = startAt; i <= stopAt; i++) {
            emit LogEvent(i,fileIndex[i]);
        }

        return true;
    }

    event Burn(address indexed burner, uint256 value);
    event Freeze(address target, bool frozen);

    event ValidateFile(uint256 index, string data);
    event ValidatePublisher(address indexed publisherAddress, bool state, string indexed publisherName);
    event ValidateWallet(address indexed walletAddress, bool state, string indexed walletName);

    event LogEvent(uint256 index, string data) anonymous;
}
Block Uncle Number Difficulty Gas Used Reward

Analytics data

Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.