//      KLEIN v. 4.03
//      By Mitchell F. Chan


/*

OVERVIEW:

    This contract manages the purchase and transferral of Digital Zones of Immaterial Pictorial Sensibility.
    It reproduces the rules originally created by Yves Klein which governed the transferral of his original Zones of Immaterial Pictorial Sensibility.

    The project is described in full in the Blue Paper included in this repository.


ABI:

[{"constant":false,"inputs":[{"name":"_edition","type":"uint256"}],"name":"ritual","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"issueNewSeries","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"totalSupply","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"saleStartTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"initialPrice","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"records","outputs":[{"name":"addr","type":"address"},{"name":"price","type":"uint256"},{"name":"burned","type":"bool"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_edition","type":"uint256"}],"name":"specificTransfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"currentSeries","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"searchedRecord","type":"uint8"}],"name":"getTokenHolder","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"maxSupplyPossible","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalSold","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"zonesSwarmAddress","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"buy","outputs":[{"name":"","type":"uint256[]"}],"payable":true,"type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"fund","outputs":[],"payable":true,"type":"function"},{"constant":true,"inputs":[],"name":"issuedToDate","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"series","outputs":[{"name":"price","type":"uint256"},{"name":"seriesSupply","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"remaining","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"redeemEther","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"burnedToDate","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"inputs":[{"name":"_saleStartTime","type":"uint256"}],"payable":false,"type":"constructor"},{"payable":true,"type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"IKBedition","type":"uint256"},{"indexed":false,"name":"holderAddress","type":"address"},{"indexed":false,"name":"price","type":"uint256"},{"indexed":false,"name":"burned","type":"bool"}],"name":"UpdateRecord","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"series","type":"uint256"}],"name":"SeriesCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"edition","type":"uint256"}],"name":"Burned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_spender","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Approval","type":"event"}]

*/

pragma solidity ^0.4.15;

// token boilerplate
contract SafeMath {

  function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
      uint256 z = x + y;
      assert((z >= x) && (z >= y));
      return z;
  }

  function safeSubtract(uint256 x, uint256 y) internal returns(uint256) {
      assert(x >= y);
      uint256 z = x - y;
      return z;
  }

  function safeMult(uint256 x, uint256 y) internal returns(uint256) {
      uint256 z = x * y;
      assert((x == 0) || (z / x == y));
      return z;
  }
}

//  token boilerplate
contract owned {
    address public owner;

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

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

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

// interface for ERC20 standard token
contract ERC20 {
    function totalSupply() constant returns (uint256 totalSupply);
    function balanceOf(address _owner) public constant returns (uint256 balance);
    function transfer(address _to, uint256 _value) returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
    function approve(address _spender, uint256 _value) returns (bool success);
    function allowance(address _owner, address _spender) constant returns (uint256 remaining);
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

contract Klein is ERC20, SafeMath, owned {
    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;

                                                                    //The Swarm address of the artwork is saved here for reference and posterity
    string public constant zonesSwarmAddress = "0a52f265d8d60a89de41a65069fa472ac3b130c269b4788811220b6546784920";
    string public constant name = "Digital Zone of Immaterial Pictorial Sensibility";
    string public constant symbol = "IKB";
    uint public constant decimals = 0;
    uint public maxSupplyPossible;
    bool first = true;
    uint public saleStartTime;                                      // will be initialized to 8:30PM EST August 30, 2017
    uint public initialPrice = 10**17;                              // should equal 0.1 ETH
    uint public currentSeries;
    uint public issuedToDate;
    uint public totalSold;
    uint public burnedToDate;
                                                                    // IKB are issued in tranches, or series of editions. There will be 8 total
                                                                    // Each IBKSeries represents one of Klein's receipt books, or a series of issued tokens.
    struct IKBSeries {
        uint price;
        uint seriesSupply;
    }

    IKBSeries[8] public series;                                     // An array of all 8 series

    struct record {
        address addr;
        uint price;
        bool burned;
    }

    record[101] public records;                                     // An array of all 101 records

    event UpdateRecord(uint indexed IKBedition, address holderAddress, uint256 price, bool burned);
    event SeriesCreated(uint indexed series);

    /* In regards to the artwork itself, do we want to record when an edition is burnt? */
    /* MFC: This is a really good point, actually, and one that I should think about further.  */
    // event Burned(uint indexed edition);

    function Klein(uint256 _saleStartTime) {
        saleStartTime = _saleStartTime;
        currentSeries = 0;
        series[0] = IKBSeries(initialPrice, 31);                    // the first series has unique values...

        for(uint i = 1; i < series.length; i++){                    // ...while the next 7 can be defined in a for loop
            series[i] = IKBSeries(series[i-1].price*2, 10);
        }
                                                                    // verifying that only 101 IKB may ever be issued.
                                                                    // it's already hardcoded that the array of records has only 101 places in it,
                                                                    // but it would be theoretically possible to issue IKB without making records, so this proof is important.

        /* Why declare maxSupplyPossible this way instead of declaring it as 101? */
        /* MFC: I just wanted to be demonstrative and show my work, but yeah, let's do it your way */
        maxSupplyPossible = 101;

        /* Uints == 0 by default so these declarations is unnecessary */
        /* MFC: thanks, I wasn't aware of that */
    }

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

    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

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

    /* Function name + returned variable are the same (won't technically mess anything up but it is confusing) */
    /* MFC: Thank you! I was confused by this myself, as I borrowed this code from another contract */
    function totalSupply() constant returns (uint _limit) {
      totalSupply = maxSupplyPossible;
      return totalSupply;
    }

    /* To confirm the series is created, one would usually return true instead of a string (like approve above) */
    /* MFC: changed to return true */
    /* You may want to call this in the constructor */
    /* MFC: chose not to call in constructor, because I want to be able to issue the first series manually during an event I'm doing at the gallery */

    function issueNewSeries() onlyOwner returns (bool success){

        if(!first){
            currentSeries++;                                        // the first time we run this function, don't run up the currentSeries counter. Keep it at 0
        } else if (first){
            first=false;                                            // ...but only let this work once.
        }

        /* Use requires at the top of this function instead of reverts here: require(now >= saleStartTime); */
        /* They serve the same purpose but are much cleaner */
        /* MFC: Question: will it be OK to use require() with multiple arguments separated by ||? Never actually seen this */
        if(issuedToDate >= maxSupplyPossible || issuedToDate + series[currentSeries].seriesSupply > maxSupplyPossible) revert();         //you can only issue a new series if there are no more tokens available to buy
        require(now >= saleStartTime);                           //you can only issue a new series if the sale has started
        require(balances[this] <= 0);                            //can only issue a new series if you've sold all the old ones

        /* You have SafeMath above but don't use .add! It's not a big deal as an overflow */
        /* is likely not possible, but the redundancy is worth it */
        /* MFC: done */
        balances[this] = safeAdd(balances[this], series[currentSeries].seriesSupply);
        issuedToDate = safeAdd(issuedToDate + series[currentSeries].seriesSupply);
        SeriesCreated(currentSeries);
        return true;
    }

    /* Again, returning true is what should happen here. */
    /* MFC: done */
    function buy() payable returns (bool success){
        /* If someone sends 23 Eth to series 7 with only 1 IKB left, 10.2 Eth will be lost */
        /* MFC: Hmmm.... suggestions? */
        uint amount = msg.value / series[currentSeries].price;      // calculates the number of tokens the sender will buy
        uint[] memory editionsPurchased = new uint[](amount);

        /* Again, should be requires */
        require(balances[this] > 0);
        require(msg.value > 0);

        /* With the require above, all you need to check here is balances[this] < amount */
        if (balances[this] < amount) {        // this section handles what happens if someone tries to buy more than the currently available supply
            uint256 receivable = safeMult(balances[this], series[currentSeries].price);
            uint256 returnable = safeSubtract(msg.value, receivable);
            amount = balances[this];
            /* msg.sender.transfer(returnable) will act the same (transfer will revert the function on a fail) */
            /* Either way, however, this isn't a security risk. Unless you explicitly define extra gas can be used, only 2300 extra gas */
            /* can be used from a .send or .transfer, which is not enough to even change the state of a variable */
            /* MFC: OK. Cool. I will actually rather use msg.sender.transfer(returnable) because I like the way that reads better */
            if(!msg.sender.send(returnable)) revert();              // IMPORTANT QUESTION: Is this a security risk? If the buy() function is called from a contract address rather than a wallet address, it may not have a fallback function. It could trap my send in malicious code...
        }

        /* Use .add and .sub. I don't see a vector right now, but an underflow */
        /* would be disastrous for the contract */
        /* MFC: can you explain further? I'm curious about this. */
        balances[msg.sender] += amount;                             // adds the amount to buyer's balance
        balances[this] -= amount;                                   // subtracts amount from seller's balance

        /* Again, from an artistic perspective, do we want transfers recorded */
        /* MFC: Hmmm.... */
        Transfer(this, msg.sender, amount);                         // execute an event reflecting the change

        /* From the artistic perspective, do we want a record made for every sale? The ritual may have less meaning then */
        /* MFC: So, the reason for the records (from a practical point of view) is that I need to know what everyone paid for their specific token in the event they choose to burn them */
        for(uint k = 0; k < amount; k++){                           // now let's make a record of every sale
            records[totalSold] = record(msg.sender, series[currentSeries].price, false);
            totalSold++;
            editionsPurchased[k] = totalSold;
        }

        /* return true */
        return true;                                   // ends function and returns
    }
                                                                    // when this function is called, the caller is transferring any number of tokens. The function automatically chooses the tokens with the LOWEST index to transfer.
    function transfer(address _to, uint _value) returns (bool success) {
        /* Use requires:
         require(balances[msg.sender] >= _value);
         require(_value > 0);
        Instead of this whole if/else block */
        require(balances[msg.sender] >= _value);
        require(_value > 0);
        uint recordsChanged = 0;
        for(uint k = 0; k < records.length; k++){                 // go through every record
            if(records[k].addr == msg.sender && recordsChanged < _value) {
                records[k].addr = _to;                            // change the address associated with this record
                recordsChanged++;                                 // keep track of how many records you've changed in this transfer. After you've changed as many records as there are tokens being transferred, conditions of this loop will cease to be true.
                UpdateRecord(k, _to, records[k].price, records[k].burned);
            }
        }
        /* .sub, .add */
        balances[msg.sender] = safeSubtract(balances[msg.sender], _value);
        balances[_to] = safeAdd(balances[_to], _value);

        /* Again, do we want this artistically? */
        /* It'll be much easier to see who had the IKBs with an event */
        /* MFC: OK, so to continue this conversation, I have come to the conclusion that the answer is "yes", we do want these records */
        /* For me, the artwork is about contrasting the artwork as a token vs the artwork as inherent idea */
        /* So while the artwork is a token, we have good recordkeeping and all that. After all, in this form the artwork can be a status symbol */
        /* And then when it's burned: nothing. So there's the contrast. And you help me realize the point that we shouldn't have a record for burning */
        Transfer(msg.sender, _to, _value);
            return true;

    }
                                                                    // when this function is called, the caller is transferring only 1 IKB to another account, and specifying exactly which token they would like to transfer.
    function specificTransfer(address _to, uint _edition) returns (bool success) {
        /* Again, requires and SafeMath here */
        requires(balances[msg.sender] > 0);
        requires(records[_edition].addr == msg.sender);
        balances[msg.sender] = safeSubtract(balances[msg.sender], 1);
        balances[_to] = safeAdd(balances[_to], 1);
        records[_edition].addr = _to;                           // update the records so that the record shows this person owns the

        /* Artistic question on these events as well */
        Transfer(msg.sender, _to, 1);
        UpdateRecord(_edition, _to, records[_edition].price, records[_edition].burned);
    }
                                                                    // a quick way to figure out who holds a specific token without querying the whole record. This might actually be redundant.
    function getTokenHolder(uint8 searchedRecord) public constant returns(address){
        return records[searchedRecord].addr;
    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        /* Requires instead of this if/else, SafeMath, and artistic event */
        /* Does not subtract the used _value from allowed[_from][msg.sender], allowing
            someone with any allowed _value to take all of from's IKBs */
        require(balances[_from] >= _value);
        require(allowed[_from][msg.sender] >= _value);
        require(_value > 0);
        uint recordsChanged = 0;
        for(uint k = 0; k < records.length; k++){                 // go through every record
            if(records[k].addr == _from && recordsChanged < _value) {
                records[k].addr = _to;                            // change the address associated with this record
                recordsChanged++;                                 // keep track of how many records you've changed in this transfer. After you've changed as many records as there are tokens being transferred, conditions of this loop will cease to be true.
                UpdateRecord(k, _to, records[k].price, records[k].burned);
            }
        }
        balances[_from] = safeSubtract(balances[_from], _value);
        balances[_to] = safeAdd(balances[_to], _value);
        Transfer(_from, _to, _value);
        return true;
    }
                                                                    // allows the artist to withdraw ether from the contract
    function redeemEther() onlyOwner{
        /* msg.sender.transfer(this.balance) throws an exception itself so you don't need revert */
        /* Also may want to just do owner.transfer to be extra safe */
        /* MFC: like so? */
        owner.transfer(this.balance);
    }
                                                                    // allows the artist to put ether back in the contract so that holders can execute the ritual function
    function fund() payable onlyOwner{
    }

    /* return true */
    /* requires instead of if/else */
    /* Maybe also add a require to make sure the contract has enough gold */
    function ritual(uint _edition) returns (bool success){
        require(records[_edition].addr == msg.sender);
        require(!records[_edition].burned);
        uint256 halfTheGold = records[_edition].price / 2;
        require(this.balance >= halfTheGold);
        records[_edition].addr = 0xdead;
        records[_edition].burned = true;
        burnedToDate++;
        balances[msg.sender]--;

        /* Artistically, you may want to create a River contract */
        /* that can receive funds but never disburse them instead of sending to a person */
        /* MFC: I thought about that a LOT actually! Ultimately, I thought that throwing the ETH to the miner felt more apt. */
        /* ..cause I suspect that people probably eventually found or will find gold that got thrown into the river. */

        block.coinbase.transfer(halfTheGold);         // call should fail if this contract isn't holding enough ETH
        /* Again, do we want an event */
        /* MFC: Agreed. */
        // Burned(_edition);

         return true;
        }
                                                                    // fallback function
    function() payable {
        buy();
    }
}