Poplar(🌳)

Token

0x3d2ff34915a0...712761a29cd1

HomesteadContract #21KSource VerifiedEdit this contract

Bytecode verified via sibling

This contract shares identical runtime bytecode with MyAdvancedToken (0x64f310f6...) which has been verified through compiler archaeology.

Deployed July 19, 2016 (10 years ago)Block 1,914,504

Poplar, ticker written as a tree emoji, launched with zero supply on 19 July 2016.

Homestead EraVerified Source

Historical Significance

Poplar uses a tree pictograph where the ticker string normally goes, an early instance of an emoji ERC-20 symbol on mainnet. It carries the central bank extensions: an owner who can mint into any account, freeze accounts, and set a buy and a sell price so the contract will trade its own token against ether. The deployer set the initial supply to zero, so every unit in circulation was minted after deployment rather than at it.

Context

Deployed the day before the DAO hard fork split the chain.

Token Information

Token Name

Poplar

Symbol

🌳

Decimals

Key Facts

Deployer

0x2e0220...8d3887

Deployment Block

1,914,504

Deployment Date

Jul 19, 2016, 07:48 PM

Code Size

2.6 KB

Gas at Deploy

951,925

Transactions by Year

20171

Deployment Transaction: 0xbea009ac9b573947...0f20c6e2cbd74e35

Description

A token from the ethereum.org tutorial. Balances sit in a public balanceOf mapping and transfer(to, value) moves them, throwing rather than returning false when the sender is short and checking the recipient's balance for overflow before adding to it. An allowance mapping records what each spender has been authorised for. ApproveAndCall sets the allowance and calls receiveApproval on the spender in the same transaction, so a spending contract learns of its allowance at the moment it is granted. The owner can create new units, freeze an account so it can no longer send, set a buy and a sell price at which holders trade against the contract's own ether balance and hand the role to another address. It was deployed as Poplar, with the symbol 🌳 and an opening supply of 0 base units at 4 decimal places and it answers standard() with the string Token 0.1, the label the tutorial used before ERC-20 had a number.

Source Verified

Soliditysource_reconstructed

Compiler: 0.3.1+c

View verification proof

soljson v0.3.1+commit.c492d9be optimizer ON. ConsenSys MyAdvancedToken template (totalSupply shadowed in MA at slot 10; transferOwnership redeclared in MA for tail placement; mintToken events use owner not this; transfer override checks balance/overflow then frozen). 20/20 selectors, 11/11 storage slots, 42/44 EVM bodies byte-for-byte PC-normalized. Verify: github.com/cartoonitunes/awesome-ethereum-proofs/tree/main/proofs/kin-token/

Historian Categories

Token

Heuristic Analysis

The following characteristics were detected through bytecode analysis and may not be accurate.

Detected Type: Token

Has ERC-20-like patterns

Homestead Era

The first planned hard fork. Removed the canary contract, adjusted gas costs.

Block span: 1,150,000 — 1,919,999

March 14, 2016 — July 20, 2016

Bytecode Overview

Opcodes2,637

Unique Opcodes167

Jump Instructions127

Storage Operations81

Verified Source Available

This contract has verified source code.

View Verification Proof

Show source code (Solidity)

contract owned {
    address public owner;

    function owned() {
        owner = msg.sender;
    }

    modifier onlyOwner {
        if (msg.sender != owner) throw;
        _
    }

    function transferOwnership(address newOwner) onlyOwner {
        owner = newOwner;
    }
}

contract tokenRecipient {
    function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}

contract token {
    string public standard = "Token 0.1";
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

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

    function token(
        uint256 initialSupply,
        string tokenName,
        uint8 decimalUnits,
        string tokenSymbol
    ) {
        balanceOf[msg.sender] = initialSupply;
        totalSupply = initialSupply;
        name = tokenName;
        symbol = tokenSymbol;
        decimals = decimalUnits;
    }

    function transfer(address _to, uint256 _value) {
        if (balanceOf[msg.sender] < _value) throw;
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        Transfer(msg.sender, _to, _value);
    }

    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        tokenRecipient spender = tokenRecipient(_spender);
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (balanceOf[_from] < _value) throw;
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;
        if (_value > allowance[_from][msg.sender]) throw;
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        allowance[_from][msg.sender] -= _value;
        Transfer(_from, _to, _value);
        return true;
    }

    function () {
        throw;
    }
}

contract MyAdvancedToken is owned, token {
    uint256 public sellPrice;
    uint256 public buyPrice;
    uint256 public totalSupply;

    mapping (address => bool) public frozenAccount;

    event FrozenFunds(address target, bool frozen);

    function MyAdvancedToken(
        uint256 initialSupply,
        string tokenName,
        uint8 decimalUnits,
        string tokenSymbol,
        address centralMinter
    ) token (initialSupply, tokenName, decimalUnits, tokenSymbol) {
        if (centralMinter != 0) owner = centralMinter;
        totalSupply = initialSupply;
    }

    function transfer(address _to, uint256 _value) {
        if (balanceOf[msg.sender] < _value) throw;
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;
        if (frozenAccount[msg.sender]) throw;
        balanceOf[msg.sender] -= _value;
        balanceOf[_to] += _value;
        Transfer(msg.sender, _to, _value);
    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (frozenAccount[_from]) throw;
        if (balanceOf[_from] < _value) throw;
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;
        if (_value > allowance[_from][msg.sender]) throw;
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        allowance[_from][msg.sender] -= _value;
        Transfer(_from, _to, _value);
        return true;
    }

    function mintToken(address target, uint256 mintedAmount) onlyOwner {
        balanceOf[target] += mintedAmount;
        totalSupply += mintedAmount;
        Transfer(0, owner, mintedAmount);
        Transfer(owner, target, mintedAmount);
    }

    function freezeAccount(address target, bool freeze) onlyOwner {
        frozenAccount[target] = freeze;
        FrozenFunds(target, freeze);
    }

    function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;
    }

    function buy() {
        uint amount = msg.value / buyPrice;
        if (balanceOf[this] < amount) throw;
        balanceOf[msg.sender] += amount;
        balanceOf[this] -= amount;
        Transfer(this, msg.sender, amount);
    }

    function sell(uint256 amount) {
        if (balanceOf[msg.sender] < amount) throw;
        balanceOf[this] += amount;
        balanceOf[msg.sender] -= amount;
        if (!msg.sender.send(amount * sellPrice)) throw;
        Transfer(msg.sender, this, amount);
    }

    function transferOwnership(address newOwner) onlyOwner {
        owner = newOwner;
    }
}