Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity ^0.5.0;

import "./UpgradeabilityProxy.sol";
import "./TokenStorage.sol";
import "./OwnershipStorage.sol";

contract TokenProxy is UpgradeabilityProxy, TokenStorage, OwnershipStorage {
    constructor (
        string memory name,
        string memory symbol,
        uint8 decimals
    ) 
        public 
    {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
        _tokensMinted = false;
    } 
}

pragma solidity ^0.5.0;

/**
 * @title ERC20 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-20
 */
interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);

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

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

    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);
}

pragma solidity ^0.5.0;

contract OwnershipStorage {
    address internal _admin;

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

    function admin() public view returns (address) {
        return _admin;
    }

    function setNewAdmin(address newAdmin) public {
        require(msg.sender == _admin);
        require(newAdmin != address(0));
        _admin = newAdmin;
    }
}

pragma solidity ^0.5.0;

contract Proxy {
    function implementation() public view returns (address);

    function() payable external {
        address _impl = implementation();
        require(_impl != address(0));
        bytes memory data = msg.data;

        // forward the call to the implemetation contract
        assembly {
            let result := delegatecall(gas, _impl, add(data, 0x20), mload(data), 0, 0)
            let size := returndatasize
            let ptr := mload(0x40)
            returndatacopy(ptr, 0, size)
            switch result
            case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }
    }
}

pragma solidity ^0.5.0;

/**
 * @title Helps contracts guard against reentrancy attacks.
 * @dev If you mark a function `nonReentrant`, you should also
 * mark it `external`.
 */
contract ReentrancyGuard {
    /// @dev counter to allow mutex lock with only one SSTORE operation
    uint256 private _guardCounter;

    constructor () internal {
        // The counter starts at one to prevent changing it from zero to a non-zero
        // value, which is a more expensive operation.
        _guardCounter = 1;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter);
    }
}

pragma solidity ^0.5.0;

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
     * @dev Multiplies two unsigned integers, reverts on overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    /**
     * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Adds two unsigned integers, reverts on overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
     * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
     * reverts when dividing by zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

pragma solidity ^0.5.0;

contract TokenStorage {
    string internal _name;
    string internal _symbol;
    uint8 internal _decimals;
    uint256 internal _totalSupply;
    mapping(address => uint256) internal _balances;
    mapping(address => mapping(address => uint256)) internal _allowances;
    bool internal _tokensMinted = true;
}

pragma solidity ^0.5.0;

import "./UpgradeableTokenStorage.sol";
import "./SafeMath.sol";
import "./IERC20.sol";

contract TokenV0 is IERC20, UpgradeableTokenStorage {
    using SafeMath for uint256;

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @return the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @return the symbol of the token.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @return the number of decimals of the token.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev Total number of tokens in existence
     */
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev Gets the balance of the specified address.
     * @param owner The address to query the balance of.
     * @return A uint256 representing the amount owned by the passed address.
     */
    function balanceOf(address owner) public view returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     * @param owner address The address which owns the funds.
     * @param spender address The address which will spend the funds.
     * @return A uint256 specifying the amount of tokens still available for the spender.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev Transfer token to a specified address
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function transfer(address to, uint256 value) public returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    /**
     * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
     * Beware that changing an allowance with this method brings the risk that someone may use both the old
     * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
     * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     */
    function approve(address spender, uint256 value) public returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    /**
     * @dev Transfer tokens from one address to another.
     * Note that while this function emits an Approval event, this is not required as per the specification,
     * and other compliant implementations may not emit the event.
     * @param from address The address which you want to send tokens from
     * @param to address The address which you want to transfer to
     * @param value uint256 the amount of tokens to be transferred
     */
    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        _transfer(from, to, value);
        _approve(from, msg.sender, _allowances[from][msg.sender].sub(value));
        return true;
    }

    /**
     * @dev Function that mints an amount of the token and assigns it to
     * an account. This encapsulates the modification of balances such that the
     * proper events are emitted. Minting allowed only once.
     * @param account The account that will receive the created tokens.
     * @param value The amount that will be created.
     */
    function mint(address account, uint256 value) public {
        require(!_tokensMinted);
        require(msg.sender == _admin);
        require(account != address(0));

        _tokensMinted = true;
        _totalSupply = _totalSupply.add(value);
        _balances[account] = _balances[account].add(value);
        emit Transfer(address(0), account, value);
    }

    /**
     * @dev Transfer token for a specified addresses
     * @param from The address to transfer from.
     * @param to The address to transfer to.
     * @param value The amount to be transferred.
     */
    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0));
        
        _balances[from] = _balances[from].sub(value);
        _balances[to] = _balances[to].add(value);
        emit Transfer(from, to, value);
    }

    /**
     * @dev Approve an address to spend another addresses' tokens.
     * @param owner The address that owns the tokens.
     * @param spender The address that will spend the tokens.
     * @param value The number of tokens that can be spent.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        require(spender != address(0));
        require(owner != address(0));

        _allowances[owner][spender] = value;
        emit Approval(owner, spender, value);
    }
}

pragma solidity ^0.5.0;

import "./Proxy.sol";
import "./UpgradeabilityStorage.sol";

contract UpgradeabilityProxy is Proxy, UpgradeabilityStorage {
    function admin() public view returns (address);

    event Upgraded(string version, address indexed implementation);

    function upgradeTo(string memory version, address implementation) public {
        require(msg.sender == admin());
        require(_implementation != implementation);
        _version = version;
        _implementation = implementation;
        emit Upgraded(version, implementation);
    }
}

pragma solidity ^0.5.0;

contract UpgradeabilityStorage {
    string internal _version;
    address internal _implementation;

    function version() public view returns (string memory) {
        return _version;
    }

    function implementation() public view returns (address) {
        return _implementation;
    }
}

pragma solidity ^0.5.0;

import "./UpgradeabilityProxy.sol";
import "./TokenStorage.sol";
import "./OwnershipStorage.sol";

contract UpgradeableTokenStorage is UpgradeabilityProxy, TokenStorage, OwnershipStorage {}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"version","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"version","type":"string"},{"name":"implementation","type":"address"}],"name":"upgradeTo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"implementation","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newAdmin","type":"address"}],"name":"setNewAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"admin","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"name","type":"string"},{"name":"symbol","type":"string"},{"name":"decimals","type":"uint8"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"version","type":"string"},{"indexed":true,"name":"implementation","type":"address"}],"name":"Upgraded","type":"event"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000007504458436f696e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035044580000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): PDXCoin
Arg [1] : symbol (string): PDX
Arg [2] : decimals (uint8): 18

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [4] : 504458436f696e00000000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [6] : 5044580000000000000000000000000000000000000000000000000000000000

124:322:5:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;146:13:2;162:16;:14;:16::i;:::-;146:32;;213:1;196:19;;:5;:19;;;;188:28;;;;;;;;226:17;246:8;;226:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;226:28:2;;;;;;;;418:1;415;408:4;402:11;395:4;389;385:15;378:5;373:3;360:60;445:14;489:4;483:11;530:4;527:1;522:3;507:28;555:6;579:1;574:28;;;;637:4;632:3;625:17;574:28;595:4;590:3;583:17;131:87:9;;8:9:-1;5:2;;;30:1;27;20:12;5:2;131:87:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;131:87:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;275:290:8;;8:9:-1;5:2;;;30:1;27;20:12;5:2;275:290:8;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;275:290:8;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;275:290:8;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;275:290:8;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;275:290:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;275:290:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;224:95:9;;8:9:-1;5:2;;;30:1;27;20:12;5:2;224:95:9;;;;;;;;;;;;;;;;;;;;;;;;;;;234:160:1;;8:9:-1;5:2;;;30:1;27;20:12;5:2;234:160:1;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;234:160:1;;;;;;;;;;;;;;;;;;;;;;151:77;;8:9:-1;5:2;;;30:1;27;20:12;5:2;151:77:1;;;;;;;;;;;;;;;;;;;;;;;;;;;224:95:9;271:7;297:15;;;;;;;;;;;290:22;;224:95;:::o;131:87::-;171:13;203:8;196:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;131:87;:::o;275:290:8:-;380:7;:5;:7::i;:::-;366:21;;:10;:21;;;358:30;;;;;;;;425:14;406:33;;:15;;;;;;;;;;;:33;;;;398:42;;;;;;;;461:7;450:8;:18;;;;;;;;;;;;:::i;:::-;;496:14;478:15;;:32;;;;;;;;;;;;;;;;;;543:14;525:33;;;534:7;525:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;525:33:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;275:290;;:::o;234:160:1:-;312:6;;;;;;;;;;;298:20;;:10;:20;;;290:29;;;;;;;;357:1;337:22;;:8;:22;;;;329:31;;;;;;;;379:8;370:6;;:17;;;;;;;;;;;;;;;;;;234:160;:::o;151:77::-;189:7;215:6;;;;;;;;;;;208:13;;151:77;:::o;124:322:5:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

bzzr://ffa7b5d3b759f82eb87368c7c7bfc956e0cbaac4e9a15204e50772d6b290b090