Comparer le texte

Trouver la différence entre deux fichiers texte

Éditeur live

Cacher identiques

Sans retour à la ligne

Vue

Niveau de précision

Coloration syntaxique

Diffchecker Desktop La façon la plus sécurisée d'utiliser Diffchecker. Obtenez l'application Diffchecker Desktop : vos diffs ne quittent jamais votre ordinateur !Obtenir Desktop

CryptoPunks v1 vs. v2

Créé il y a 4 ansLe diff n'expire jamais

21 suppressions

Lignes
Total
Supprimé

Caractères
Total
Supprimé

Pour continuer à utiliser cette fonctionnalité, passez à Diffchecker Pro Voir les prix

140 lignes

129 ajouts

Lignes
Total
Ajouté

Caractères
Total
Ajouté

Pour continuer à utiliser cette fonctionnalité, passez à Diffchecker Pro Voir les prix

250 lignes

/**

*Submitted for verification at Etherscan.io on 2017-06-17

*Submitted for verification at Etherscan.io on 2017-07-19

pragma solidity ^0.4.8;

contract CryptoPunks {

contract CryptoPunksMarket {

// You can use this hash to verify the image file containing all the punks

string public imageHash = "ac39af4793119ee46bbff351d8cb6b5f23da60222126add4268e261199a2921b";

address owner;

string public standard = 'CryptoPunks';

string public name;

string public symbol;

uint8 public decimals;

uint256 public totalSupply;

uint public nextPunkIndexToAssign = 0;

//bool public allPunksAssigned = false;

bool public allPunksAssigned = false;

uint public punksRemainingToAssign = 0;

uint public numberOfPunksToReserve;

uint public numberOfPunksReserved = 0;

//mapping (address => uint) public addressToPunkIndex;

mapping (uint => address) public punkIndexToAddress;

/* This creates an array with all balances */

mapping (address => uint256) public balanceOf;

struct Offer {

bool isForSale;

uint punkIndex;

address seller;

uint minValue; // in ether

address onlySellTo; // specify to sell only to a specific person

}

struct Bid {

bool hasBid;

uint punkIndex;

address bidder;

uint value;

}

// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person

mapping (uint => Offer) public punksOfferedForSale;

// A record of the highest punk bid

mapping (uint => Bid) public punkBids;

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);

/* Initializes contract with initial supply tokens to the creator of the contract */

function CryptoPunks() payable {

function CryptoPunksMarket() payable {

// balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens

owner = msg.sender;

totalSupply = 10000; // Update total supply

punksRemainingToAssign = totalSupply;

numberOfPunksToReserve = 1000;

name = "CRYPTOPUNKS"; // Set the name for display purposes

symbol = "Ͼ"; // Set the symbol for display purposes

decimals = 0; // Amount of decimals for display purposes

}

function reservePunksForOwner(uint maxForThisRun) {

function setInitialOwner(address to, uint punkIndex) {

if (msg.sender != owner) throw;

if (numberOfPunksReserved >= numberOfPunksToReserve) throw;

if (allPunksAssigned) throw;

uint numberPunksReservedThisRun = 0;

if (punkIndex >= 10000) throw;

while (numberOfPunksReserved < numberOfPunksToReserve && numberPunksReservedThisRun < maxForThisRun) {

if (punkIndexToAddress[punkIndex] != to) {

punkIndexToAddress[nextPunkIndexToAssign] = msg.sender;

if (punkIndexToAddress[punkIndex] != 0x0) {

Assign(msg.sender, nextPunkIndexToAssign);

balanceOf[punkIndexToAddress[punkIndex]]--;

numberPunksReservedThisRun++;

} else {

nextPunkIndexToAssign++;

punksRemainingToAssign--;

}

punkIndexToAddress[punkIndex] = to;

balanceOf[to]++;

Assign(to, punkIndex);

}

punksRemainingToAssign -= numberPunksReservedThisRun;

}

numberOfPunksReserved += numberPunksReservedThisRun;

balanceOf[msg.sender] += numberPunksReservedThisRun;

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]);

}

function allInitialOwnersAssigned() {

if (msg.sender != owner) throw;

allPunksAssigned = true;

}

function getPunk(uint punkIndex) {

if (!allPunksAssigned) throw;

if (punksRemainingToAssign == 0) throw;

if (punkIndexToAddress[punkIndex] != 0x0) throw;

if (punkIndex >= 10000) throw;

punkIndexToAddress[punkIndex] = msg.sender;

balanceOf[msg.sender]++;

punksRemainingToAssign--;

Assign(msg.sender, punkIndex);

}

// Transfer ownership of a punk to another user without requiring payment

function transferPunk(address to, uint punkIndex) {

if (!allPunksAssigned) throw;

if (punkIndexToAddress[punkIndex] != msg.sender) throw;

if (punkIndex >= 10000) throw;

if (punksOfferedForSale[punkIndex].isForSale) {

punkNoLongerForSale(punkIndex);

}

punkIndexToAddress[punkIndex] = to;

balanceOf[msg.sender]--;

balanceOf[to]++;

Transfer(msg.sender, to, 1);

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.

Bid bid = punkBids[punkIndex];

if (bid.bidder == to) {

// Kill bid and refund value

pendingWithdrawals[to] += bid.value;

punkBids[punkIndex] = Bid(false, punkIndex, 0x0, 0);

}

function punkNoLongerForSale(uint punkIndex) {

if (!allPunksAssigned) throw;

if (punkIndexToAddress[punkIndex] != msg.sender) throw;

if (punkIndex >= 10000) throw;

punksOfferedForSale[punkIndex] = Offer(false, punkIndex, msg.sender, 0, 0x0);

PunkNoLongerForSale(punkIndex);

}

function offerPunkForSale(uint punkIndex, uint minSalePriceInWei) {

if (!allPunksAssigned) throw;

if (punkIndexToAddress[punkIndex] != msg.sender) throw;

if (punkIndex >= 10000) throw;

punksOfferedForSale[punkIndex] = Offer(true, punkIndex, msg.sender, minSalePriceInWei, 0x0);

PunkOffered(punkIndex, minSalePriceInWei, 0x0);

}

function offerPunkForSaleToAddress(uint punkIndex, uint minSalePriceInWei, address toAddress) {

if (!allPunksAssigned) throw;

if (punkIndexToAddress[punkIndex] != msg.sender) throw;

if (punkIndex >= 10000) throw;

punksOfferedForSale[punkIndex] = Offer(true, punkIndex, msg.sender, minSalePriceInWei, toAddress);

PunkOffered(punkIndex, minSalePriceInWei, toAddress);

}

function buyPunk(uint punkIndex) payable {

if (!allPunksAssigned) throw;

Offer offer = punksOfferedForSale[punkIndex];

if (punkIndex >= 10000) throw;

if (!offer.isForSale) throw; // punk not actually for sale

if (offer.onlySellTo != 0x0 && offer.onlySellTo != msg.sender) throw; // punk not supposed to be sold to this user

if (msg.value < offer.minValue) throw; // Didn't send enough ETH

if (offer.seller != punkIndexToAddress[punkIndex]) throw; // Seller no longer owner of punk

address seller = offer.seller;

punkIndexToAddress[punkIndex] = msg.sender;

balanceOf[offer.seller]--;

balanceOf[seller]--;

balanceOf[msg.sender]++;

Transfer(offer.seller, msg.sender, 1);

Transfer(seller, msg.sender, 1);

punkNoLongerForSale(punkIndex);

pendingWithdrawals[offer.seller] += msg.value;

pendingWithdrawals[seller] += msg.value;

PunkBought(punkIndex, msg.value, offer.seller, msg.sender);

PunkBought(punkIndex, msg.value, seller, msg.sender);

// Check for the case where there is a bid from the new owner and refund it.

// Any other bid can stay in place.

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);

}

function withdraw() {

if (!allPunksAssigned) throw;

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);

}

function enterBidForPunk(uint punkIndex) payable {

if (punkIndex >= 10000) throw;

if (!allPunksAssigned) throw;

if (punkIndexToAddress[punkIndex] == 0x0) throw;

if (punkIndexToAddress[punkIndex] == msg.sender) throw;

if (msg.value == 0) throw;

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;

if (!allPunksAssigned) throw;

if (punkIndexToAddress[punkIndex] != msg.sender) throw;

address seller = msg.sender;

Bid bid = punkBids[punkIndex];

if (bid.value == 0) throw;

if (bid.value < minPrice) throw;

punkIndexToAddress[punkIndex] = bid.bidder;

balanceOf[seller]--;

balanceOf[bid.bidder]++;

Transfer(seller, bid.bidder, 1);

punksOfferedForSale[punkIndex] = Offer(false, punkIndex, bid.bidder, 0, 0x0);

uint amount = bid.value;

punkBids[punkIndex] = Bid(false, punkIndex, 0x0, 0);

pendingWithdrawals[seller] += amount;

PunkBought(punkIndex, bid.value, seller, bid.bidder);

}

function withdrawBidForPunk(uint punkIndex) {

if (punkIndex >= 10000) throw;

if (!allPunksAssigned) throw;

if (punkIndexToAddress[punkIndex] == 0x0) throw;

if (punkIndexToAddress[punkIndex] == msg.sender) throw;

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);

}

Différences enregistrées

Texte d'origine

Ouvrir un fichier

/**
 *Submitted for verification at Etherscan.io on 2017-06-17
*/

pragma solidity ^0.4.8;
contract CryptoPunks {

// You can use this hash to verify the image file containing all the punks
    string public imageHash = "ac39af4793119ee46bbff351d8cb6b5f23da60222126add4268e261199a2921b";

address owner;

string public standard = 'CryptoPunks';
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

uint public nextPunkIndexToAssign = 0;

//bool public allPunksAssigned = false;
    uint public punksRemainingToAssign = 0;
    uint public numberOfPunksToReserve;
    uint public numberOfPunksReserved = 0;

//mapping (address => uint) public addressToPunkIndex;
    mapping (uint => address) public punkIndexToAddress;

/* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;

struct Offer {
        bool isForSale;
        uint punkIndex;
        address seller;
        uint minValue;          // in ether
        address onlySellTo;     // specify to sell only to a specific person
    }

// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
    mapping (uint => Offer) public punksOfferedForSale;

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 PunkBought(uint indexed punkIndex, uint value, address indexed fromAddress, address indexed toAddress);
    event PunkNoLongerForSale(uint indexed punkIndex);

/* Initializes contract with initial supply tokens to the creator of the contract */
    function CryptoPunks() payable {
        //        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        owner = msg.sender;
        totalSupply = 10000;                        // Update total supply
        punksRemainingToAssign = totalSupply;
        numberOfPunksToReserve = 1000;
        name = "CRYPTOPUNKS";                                   // Set the name for display purposes
        symbol = "Ͼ";                               // Set the symbol for display purposes
        decimals = 0;                                       // Amount of decimals for display purposes
    }

function reservePunksForOwner(uint maxForThisRun) {
        if (msg.sender != owner) throw;
        if (numberOfPunksReserved >= numberOfPunksToReserve) throw;
        uint numberPunksReservedThisRun = 0;
        while (numberOfPunksReserved < numberOfPunksToReserve && numberPunksReservedThisRun < maxForThisRun) {
            punkIndexToAddress[nextPunkIndexToAssign] = msg.sender;
            Assign(msg.sender, nextPunkIndexToAssign);
            numberPunksReservedThisRun++;
            nextPunkIndexToAssign++;
        }
        punksRemainingToAssign -= numberPunksReservedThisRun;
        numberOfPunksReserved += numberPunksReservedThisRun;
        balanceOf[msg.sender] += numberPunksReservedThisRun;
    }

function getPunk(uint punkIndex) {
        if (punksRemainingToAssign == 0) throw;
        if (punkIndexToAddress[punkIndex] != 0x0) throw;
        punkIndexToAddress[punkIndex] = msg.sender;
        balanceOf[msg.sender]++;
        punksRemainingToAssign--;
        Assign(msg.sender, punkIndex);
    }

// Transfer ownership of a punk to another user without requiring payment
    function transferPunk(address to, uint punkIndex) {
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        punkIndexToAddress[punkIndex] = to;
        balanceOf[msg.sender]--;
        balanceOf[to]++;
        Transfer(msg.sender, to, 1);
        PunkTransfer(msg.sender, to, punkIndex);
    }

function punkNoLongerForSale(uint punkIndex) {
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        punksOfferedForSale[punkIndex] = Offer(false, punkIndex, msg.sender, 0, 0x0);
        PunkNoLongerForSale(punkIndex);
    }

function offerPunkForSale(uint punkIndex, uint minSalePriceInWei) {
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        punksOfferedForSale[punkIndex] = Offer(true, punkIndex, msg.sender, minSalePriceInWei, 0x0);
        PunkOffered(punkIndex, minSalePriceInWei, 0x0);
    }

function offerPunkForSaleToAddress(uint punkIndex, uint minSalePriceInWei, address toAddress) {
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        punksOfferedForSale[punkIndex] = Offer(true, punkIndex, msg.sender, minSalePriceInWei, toAddress);
        PunkOffered(punkIndex, minSalePriceInWei, toAddress);
    }

function buyPunk(uint punkIndex) payable {
        Offer offer = punksOfferedForSale[punkIndex];
        if (!offer.isForSale) throw;                // punk not actually for sale
        if (offer.onlySellTo != 0x0 && offer.onlySellTo != msg.sender) throw;  // punk not supposed to be sold to this user
        if (msg.value < offer.minValue) throw;      // Didn't send enough ETH
        if (offer.seller != punkIndexToAddress[punkIndex]) throw; // Seller no longer owner of punk

punkIndexToAddress[punkIndex] = msg.sender;
        balanceOf[offer.seller]--;
        balanceOf[msg.sender]++;
        Transfer(offer.seller, msg.sender, 1);

punkNoLongerForSale(punkIndex);
        pendingWithdrawals[offer.seller] += msg.value;
        PunkBought(punkIndex, msg.value, offer.seller, msg.sender);
    }

function withdraw() {
        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);
    }
}

Texte modifié

Ouvrir un fichier

/**
 *Submitted for verification at Etherscan.io on 2017-07-19
*/

pragma solidity ^0.4.8;
contract CryptoPunksMarket {

// You can use this hash to verify the image file containing all the punks
    string public imageHash = "ac39af4793119ee46bbff351d8cb6b5f23da60222126add4268e261199a2921b";

address owner;

string public standard = 'CryptoPunks';
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

uint public nextPunkIndexToAssign = 0;

bool public allPunksAssigned = false;
    uint public punksRemainingToAssign = 0;

//mapping (address => uint) public addressToPunkIndex;
    mapping (uint => address) public punkIndexToAddress;

/* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;

struct Bid {
        bool hasBid;
        uint punkIndex;
        address bidder;
        uint value;
    }

// A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
    mapping (uint => Offer) public punksOfferedForSale;

// A record of the highest punk bid
    mapping (uint => Bid) public punkBids;

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);

/* Initializes contract with initial supply tokens to the creator of the contract */
    function CryptoPunksMarket() payable {
        //        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        owner = msg.sender;
        totalSupply = 10000;                        // Update total supply
        punksRemainingToAssign = totalSupply;
        name = "CRYPTOPUNKS";                                   // Set the name for display purposes
        symbol = "Ͼ";                               // Set the symbol for display purposes
        decimals = 0;                                       // Amount of decimals for display purposes
    }

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]);
        }
    }

function allInitialOwnersAssigned() {
        if (msg.sender != owner) throw;
        allPunksAssigned = true;
    }

function getPunk(uint punkIndex) {
        if (!allPunksAssigned) throw;
        if (punksRemainingToAssign == 0) throw;
        if (punkIndexToAddress[punkIndex] != 0x0) throw;
        if (punkIndex >= 10000) throw;
        punkIndexToAddress[punkIndex] = msg.sender;
        balanceOf[msg.sender]++;
        punksRemainingToAssign--;
        Assign(msg.sender, punkIndex);
    }

// Transfer ownership of a punk to another user without requiring payment
    function transferPunk(address to, uint punkIndex) {
        if (!allPunksAssigned) throw;
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        if (punkIndex >= 10000) throw;
        if (punksOfferedForSale[punkIndex].isForSale) {
            punkNoLongerForSale(punkIndex);
        }
        punkIndexToAddress[punkIndex] = to;
        balanceOf[msg.sender]--;
        balanceOf[to]++;
        Transfer(msg.sender, to, 1);
        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.
        Bid bid = punkBids[punkIndex];
        if (bid.bidder == to) {
            // Kill bid and refund value
            pendingWithdrawals[to] += bid.value;
            punkBids[punkIndex] = Bid(false, punkIndex, 0x0, 0);
        }
    }

function punkNoLongerForSale(uint punkIndex) {
        if (!allPunksAssigned) throw;
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        if (punkIndex >= 10000) throw;
        punksOfferedForSale[punkIndex] = Offer(false, punkIndex, msg.sender, 0, 0x0);
        PunkNoLongerForSale(punkIndex);
    }

function offerPunkForSale(uint punkIndex, uint minSalePriceInWei) {
        if (!allPunksAssigned) throw;
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        if (punkIndex >= 10000) throw;
        punksOfferedForSale[punkIndex] = Offer(true, punkIndex, msg.sender, minSalePriceInWei, 0x0);
        PunkOffered(punkIndex, minSalePriceInWei, 0x0);
    }

function offerPunkForSaleToAddress(uint punkIndex, uint minSalePriceInWei, address toAddress) {
        if (!allPunksAssigned) throw;
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        if (punkIndex >= 10000) throw;
        punksOfferedForSale[punkIndex] = Offer(true, punkIndex, msg.sender, minSalePriceInWei, toAddress);
        PunkOffered(punkIndex, minSalePriceInWei, toAddress);
    }

function buyPunk(uint punkIndex) payable {
        if (!allPunksAssigned) throw;
        Offer offer = punksOfferedForSale[punkIndex];
        if (punkIndex >= 10000) throw;
        if (!offer.isForSale) throw;                // punk not actually for sale
        if (offer.onlySellTo != 0x0 && offer.onlySellTo != msg.sender) throw;  // punk not supposed to be sold to this user
        if (msg.value < offer.minValue) throw;      // Didn't send enough ETH
        if (offer.seller != punkIndexToAddress[punkIndex]) throw; // Seller no longer owner of punk

address seller = offer.seller;

punkIndexToAddress[punkIndex] = msg.sender;
        balanceOf[seller]--;
        balanceOf[msg.sender]++;
        Transfer(seller, msg.sender, 1);

punkNoLongerForSale(punkIndex);
        pendingWithdrawals[seller] += msg.value;
        PunkBought(punkIndex, msg.value, seller, msg.sender);

// Check for the case where there is a bid from the new owner and refund it.
        // Any other bid can stay in place.
        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);
        }
    }

function withdraw() {
        if (!allPunksAssigned) throw;
        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);
    }

function enterBidForPunk(uint punkIndex) payable {
        if (punkIndex >= 10000) throw;
        if (!allPunksAssigned) throw;                
        if (punkIndexToAddress[punkIndex] == 0x0) throw;
        if (punkIndexToAddress[punkIndex] == msg.sender) throw;
        if (msg.value == 0) throw;
        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;
        if (!allPunksAssigned) throw;                
        if (punkIndexToAddress[punkIndex] != msg.sender) throw;
        address seller = msg.sender;
        Bid bid = punkBids[punkIndex];
        if (bid.value == 0) throw;
        if (bid.value < minPrice) throw;

punkIndexToAddress[punkIndex] = bid.bidder;
        balanceOf[seller]--;
        balanceOf[bid.bidder]++;
        Transfer(seller, bid.bidder, 1);

punksOfferedForSale[punkIndex] = Offer(false, punkIndex, bid.bidder, 0, 0x0);
        uint amount = bid.value;
        punkBids[punkIndex] = Bid(false, punkIndex, 0x0, 0);
        pendingWithdrawals[seller] += amount;
        PunkBought(punkIndex, bid.value, seller, bid.bidder);
    }

function withdrawBidForPunk(uint punkIndex) {
        if (punkIndex >= 10000) throw;
        if (!allPunksAssigned) throw;                
        if (punkIndexToAddress[punkIndex] == 0x0) throw;
        if (punkIndexToAddress[punkIndex] == msg.sender) throw;
        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);
    }

}