cryptopunks的代码解释

1.imageHash
就是将punk所有图像合在一起的那张图punks.png进行hash得到一个值，并将该值存储到链上，用处就是你可以通过将图像hash然后跟该值对比看图像对不对。这就是它的用处，在代码中它没用。即该图punks.png，在https://github.com/larvalabs/cryptopunks/tree/master/test能得到：

2.函数简单介绍
CryptoPunksMarket
创建10000个token，该合同的拥有者即该合约的部署者owner = msg.sender

setInitialOwner\setInitialOwners
将token初始无偿送给一些用户的函数，只有合同拥有者才能调用这两个函数（if (msg.sender != owner) throw;）当变量allPunksAssigned为false时这两个函数才能调用，这时候其他的函数都不能调用。该两个函数是在合同刚部署时使用的，因为当allPunksAssigned被设为true后，这两个函数将永远不能被调用。即使一个token刚刚送给了别的用户，合同拥有者还是能通过函数setInitialOwner将其拿回，转送给另一个用户

allInitialOwnersAssigned
将变量allPunksAssigned设为true，这样，上面的两个无偿赠送的函数就不能使用了，只能使用下面的其他函数

getPunk
用户还是可以通过这份函数来无偿获得token，不同之处在于：
首先不需要是合同拥有者也能调用这个函数，但是这有那些无主的token才能被get

transferPunk
把自己拥有的token转赠给别的用户

punkNoLongerForSale
把之前标价打算要卖出去的token取消了，就是不打算sell了

offerPunkForSale
把自己的token标一个最低价想要卖出

offerPunkForSaleToAddress
把自己的token标一个最低价想要卖给一个指定的用户

buyPunk
购买那些标价卖出的token

withdraw
将自己临时账户中的钱取出来
enterBidForPunk
进入到某个token的竞标市场，只有出价比之前最高价高时该竞标才回成功，成为最高价

acceptBidForPunk
sell方接受竞标

withdrawBidForPunk
竞标方放弃竞标

3.整个代码的详细介绍

pragma solidity ^0.4.8;
contract CryptoPunksMarket {

    // 图片的hash值，用于验证图片文件的正确性
    string public imageHash = "ac39af4793119ee46bbff351d8cb6b5f23da60222126add4268e261199a2921b";

//该合约的拥有者声明
    address owner;
//该token的一些定义信息
    string public standard = 'CryptoPunks';
    string public name;
    string public symbol;
    uint8 public decimals;
//token的总量声明
    uint256 public totalSupply;

//下一个被分配的token的索引，从0开始
    uint public nextPunkIndexToAssign = 0;
//用于上锁函数
    bool public allPunksAssigned = false;
//剩余的能够进行分配的token数量
    uint public punksRemainingToAssign = 0;

//将token索引映射到拥有者的地址，punkIndexToAddress[0]即得到索引为0的token的拥有者地址
    mapping (uint => address) public punkIndexToAddress;

 //用户所拥有的token的数量
    mapping (address => uint256) public balanceOf;

//声明卖token的结构体
    struct Offer {
        bool isForSale;//true即token正在卖出
        uint punkIndex;
        address seller;//卖方，及其主人
        uint minValue;          // in ether，卖出最低价
        address onlySellTo;     //用于设置卖给谁，不设则卖给谁都可以
    }

//声明竞标token的结构体
    struct Bid {
        bool hasBid;//是否正在竞标
        uint punkIndex;
        address bidder;
        uint value;
    }

//通过token索引来查看该token的卖出信息，也可能没有
    mapping (uint => Offer) public punksOfferedForSale;

//通过token索引来查看该token的最高价竞标信息，也可能没有
    mapping (uint => Bid) public punkBids;
//用户的临时账户，存放其卖token的回报或者竞标失败退回的竞标额
    mapping (address => uint) public pendingWithdrawals;

//用于事件监听
    event Assign(address indexed to, uint256 punkIndex);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event PunkTransfer(address indexed from, address indexed to, uint256 punkIndex);
    event PunkOffered(uint indexed punkIndex, uint minValue, address indexed toAddress);
    event PunkBidEntered(uint indexed punkIndex, uint value, address indexed fromAddress);
    event PunkBidWithdrawn(uint indexed punkIndex, uint value, address indexed fromAddress);
    event PunkBought(uint indexed punkIndex, uint value, address indexed fromAddress, address indexed toAddress);
    event PunkNoLongerForSale(uint indexed punkIndex);

    //构造函数，初始化该token
    function CryptoPunksMarket() payable {

        owner = msg.sender;
        totalSupply = 10000;                        //token总数为10000
        punksRemainingToAssign = totalSupply; //余量为10000
        name = "CRYPTOPUNKS";                                   // Set the name for display purposes
        symbol = "Ͼ";                               // Set the symbol for display purposes
        decimals = 0;                                       // Amount of decimals for display purposes
    }

//合约拥有者通过调用该函数将token送给某些用户
    function setInitialOwner(address to, uint punkIndex) {
        if (msg.sender != owner) throw;    //函数调用者必须是合约拥有者
        if (allPunksAssigned) throw;      //allPunksAssigned要为false
        if (punkIndex >= 10000) throw;    //punkIndex即token的索引要小于token总数10000
        if (punkIndexToAddress[punkIndex] != to) { //token的主人不能是要送给的用户
            if (punkIndexToAddress[punkIndex] != 0x0) {//送出去的token可以收回再送给别的用户
                balanceOf[punkIndexToAddress[punkIndex]]--;
            } else {
                punksRemainingToAssign—;   //该token之前没被赠送过，可分配token数减1
            }
            punkIndexToAddress[punkIndex] = to;   //更换token拥有者为to
            balanceOf[to]++;   //to用户的token拥有总数加1
            Assign(to, punkIndex);   //事件event Assign，监听到该事件则说明该函数调用成功
        }
    }

//同时将多个token送给多个用户
    function setInitialOwners(address[] addresses, uint[] indices) {
        if (msg.sender != owner) throw;
        uint n = addresses.length;
        for (uint i = 0; i < n; i++) {
            setInitialOwner(addresses[i], indices[i]);
        }
    }
//将变量allPunksAssigned设置为true，用以停止上面两个函数的使用，开始下面函数的使用
    function allInitialOwnersAssigned() {
        if (msg.sender != owner) throw;
        allPunksAssigned = true;
    }

//任何用户都可以通过该函数来获得无主的token
    function getPunk(uint punkIndex) {
        if (!allPunksAssigned) throw;  //allPunksAssigned为true
        if (punksRemainingToAssign == 0) throw;   //剩下能够分配的token数要大于0
        if (punkIndexToAddress[punkIndex] != 0x0) throw; //只能得到无主token
        if (punkIndex >= 10000) throw;   //punkIndex即token的索引要小于token总数10000
        punkIndexToAddress[punkIndex] = msg.sender;
        balanceOf[msg.sender]++;
        punksRemainingToAssign--;
        Assign(msg.sender, punkIndex);   //事件event Assign，监听到该事件则说明该函数调用成功
    }

    // 转赠token
    function transferPunk(address to, uint punkIndex) {
        if (!allPunksAssigned) throw;   //allPunksAssigned为true
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;  //函数调用者必须是token的主人
        if (punkIndex >= 10000) throw;  //punkIndex即token的索引要小于token总数10000
        if (punksOfferedForSale[punkIndex].isForSale) {  //如果之前想要sell这个token，则先取消sell
            punkNoLongerForSale(punkIndex);
        }
        punkIndexToAddress[punkIndex] = to;
        balanceOf[msg.sender]--;
        balanceOf[to]++;
        Transfer(msg.sender, to, 1);  //事件event Transfer，监听到该事件则说明该函数调用成功
        PunkTransfer(msg.sender, to, punkIndex); //事件
        // Check for the case where there is a bid from the new owner and refund it.
        // Any other bid can stay in place.
//查看被赠方是否之前有对该token进行投标，有则取消，并将其投标的金额放进其临时账户中
        Bid bid = punkBids[punkIndex];
        if (bid.bidder == to) {
            // Kill bid and refund value
            pendingWithdrawals[to] += bid.value;
            punkBids[punkIndex] = Bid(false, punkIndex, 0x0, 0);//清空投标信息，并设置状态为false
        }
    }

//取消之前设置的token卖出信息
    function punkNoLongerForSale(uint punkIndex) {
        if (!allPunksAssigned) throw;   //allPunksAssigned为true
        if (punkIndexToAddress[punkIndex] != msg.sender) throw; //函数调用者必须是token的主人
        if (punkIndex >= 10000) throw;  //punkIndex即token的索引要小于token总数10000
//清空卖出offer信息，并设置状态为false
 punksOfferedForSale[punkIndex] = Offer(false, punkIndex, msg.sender, 0, 0x0);
        PunkNoLongerForSale(punkIndex);
    }

//想将某token卖出，将相应信息写入offer中，用以告知大家
    function offerPunkForSale(uint punkIndex, uint minSalePriceInWei) {
        if (!allPunksAssigned) throw;   //allPunksAssigned为true
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;  //函数调用者必须是token的主人
        if (punkIndex >= 10000) throw;   //punkIndex即token的索引要小于token总数10000
//将相应的信息写入结构体offer中
        punksOfferedForSale[punkIndex] = Offer(true, punkIndex, msg.sender, minSalePriceInWei, 0x0);
        PunkOffered(punkIndex, minSalePriceInWei, 0x0);//事件PunkOffered，用以告知函数调用成功
    }

//声明某token想要卖给某个特定的用户
    function offerPunkForSaleToAddress(uint punkIndex, uint minSalePriceInWei, address toAddress) {
        if (!allPunksAssigned) throw; //allPunksAssigned为true
        if (punkIndexToAddress[punkIndex] != msg.sender) throw; //函数调用者必须是token的主人
        if (punkIndex >= 10000) throw;    //punkIndex即token的索引要小于token总数10000
//将相应的信息写入结构体offer中
        punksOfferedForSale[punkIndex] = Offer(true, punkIndex, msg.sender, minSalePriceInWei, toAddress);
        PunkOffered(punkIndex, minSalePriceInWei, toAddress);//事件PunkOffered，用以告知函数调用成功
    }

//购买在offer中设置为卖出的token
    function buyPunk(uint punkIndex) payable {
        if (!allPunksAssigned) throw;      //allPunksAssigned为true
        Offer offer = punksOfferedForSale[punkIndex];  //token的卖出信息
        if (punkIndex >= 10000) throw;  //punkIndex即token的索引要小于token总数10000
        if (!offer.isForSale) throw;                // token的卖出状态要为true
//token指定的卖出用户要是函数调用者或者没有指定卖出用户
        if (offer.onlySellTo != 0x0 && offer.onlySellTo != msg.sender) throw;
        if (msg.value < offer.minValue) throw;      // 你的出价必须大于或等于offer中标出的价格
        if (offer.seller != punkIndexToAddress[punkIndex]) throw; //offer中表明的卖方必须还是token的主人

        address seller = offer.seller;

        punkIndexToAddress[punkIndex] = msg.sender;
        balanceOf[seller]--;
        balanceOf[msg.sender]++;
        Transfer(seller, msg.sender, 1); //事件Transfer，说明买卖成功

        punkNoLongerForSale(punkIndex);  //清空卖出offer信息
        pendingWithdrawals[seller] += msg.value;  //将卖出的钱msg.value写入seller的临时账户
        PunkBought(punkIndex, msg.value, seller, msg.sender); //事件

       //如果该函数调用者之前有投标过该token，则取消，并将投标钱放入临时账户中
        Bid bid = punkBids[punkIndex];
        if (bid.bidder == msg.sender) {
            // Kill bid and refund value
            pendingWithdrawals[msg.sender] += bid.value;
            punkBids[punkIndex] = Bid(false, punkIndex, 0x0, 0);//清空投标信息
        }
    }

//将临时账户中的钱拿出，其实就是要求合约地址send回钱
    function withdraw() {
        if (!allPunksAssigned) throw;   //allPunksAssigned为true
        uint amount = pendingWithdrawals[msg.sender];
        // Remember to zero the pending refund before
        // sending to prevent re-entrancy attacks
        pendingWithdrawals[msg.sender] = 0;  //清空临时账户
        msg.sender.transfer(amount);  //合约地址send回钱amount给msg.sender，即合约调用者
    }

//进入某个token的投标市场
    function enterBidForPunk(uint punkIndex) payable {
        if (punkIndex >= 10000) throw;  //punkIndex即token的索引要小于token总数10000
        if (!allPunksAssigned) throw;       //allPunksAssigned为true
        if (punkIndexToAddress[punkIndex] == 0x0) throw;  //该token要有主
        if (punkIndexToAddress[punkIndex] == msg.sender) throw;  //该token的主人不是函数调用者
        if (msg.value == 0) throw;   //投标价格一定要大于0
        Bid existing = punkBids[punkIndex];   //之前的最高价的投标信息
        if (msg.value <= existing.value) throw;   //出的投标价高于之前的最高价时，该投标才成功
        if (existing.value > 0) {//之前投标的人的投标价会返回到它的临时账户中
            // Refund the failing bid
            pendingWithdrawals[existing.bidder] += existing.value;
        }
        punkBids[punkIndex] = Bid(true, punkIndex, msg.sender, msg.value); //覆盖投标信息
        PunkBidEntered(punkIndex, msg.value, msg.sender); //事件
    }

//接受目前出最高投标价的投标者的投标
    function acceptBidForPunk(uint punkIndex, uint minPrice) {
        if (punkIndex >= 10000) throw;  //punkIndex即token的索引要小于token总数10000
        if (!allPunksAssigned) throw;    //allPunksAssigned为true
        if (punkIndexToAddress[punkIndex] != msg.sender) throw; //只有token主人才能接受投标
        address seller = msg.sender;  //卖方地址
        Bid bid = punkBids[punkIndex]; //投标信息
        if (bid.value == 0) throw;  //投标价等于0说明没人投标
        if (bid.value < minPrice) throw;  //投标价要大于接受投标的最小价格

        punkIndexToAddress[punkIndex] = bid.bidder;
        balanceOf[seller]--;
        balanceOf[bid.bidder]++;
        Transfer(seller, bid.bidder, 1);
//成功后，无论是卖出offer还是投标bid信息都要被清空，offer中的主人会换成投标者
        punksOfferedForSale[punkIndex] = Offer(false, punkIndex, bid.bidder, 0, 0x0);
        uint amount = bid.value;
        punkBids[punkIndex] = Bid(false, punkIndex, 0x0, 0);
        pendingWithdrawals[seller] += amount;  //seller赚到的钱放入临时账户
        PunkBought(punkIndex, bid.value, seller, bid.bidder);//事件
    }

//取消对某个token的投标
    function withdrawBidForPunk(uint punkIndex) {
        if (punkIndex >= 10000) throw;  //punkIndex即token的索引要小于token总数10000
        if (!allPunksAssigned) throw;       //allPunksAssigned为true
        if (punkIndexToAddress[punkIndex] == 0x0) throw;   //该token要有主
        if (punkIndexToAddress[punkIndex] == msg.sender) throw;  //该token的主人不是函数调用者
        Bid bid = punkBids[punkIndex];  //投标信息
        if (bid.bidder != msg.sender) throw;  //投标者即函数调用者
        PunkBidWithdrawn(punkIndex, bid.value, msg.sender); //事件
        uint amount = bid.value;
        punkBids[punkIndex] = Bid(false, punkIndex, 0x0, 0); //清空投标信息
        // Refund the bid money
        msg.sender.transfer(amount);  //直接将投标价send给投标者，不放入临时账户
    }

}

注：
1.为什么要设置临时账户：
因为当用户调用定义为payable的函数时，它通过msg.value    传入的金额其实已经从他的账户中转到了该合约地址当中，就是调用函数的交易的from为函数调用者，to为合约地址。当其后面想要取消该函数的调用时，比如之前投标bid了某token，后面想取消时，函数就会讲bid结构体中记录的你的投标价格放入你的临时账户中，语句msg.sender.transfer(金额数)就是合约地址将该金额转回给你了

对里面使用到的solidity的介绍，看这里solidity学习-cryptoPunks为实例