CryptoPunks v1 vs. v2

Created Diff never expires
24 removals
140 lines
135 additions
250 lines
/**
/**
*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;
pragma solidity ^0.4.8;
contract CryptoPunks {
contract CryptoPunksMarket {


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


address owner;
address owner;


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


uint public nextPunkIndexToAssign = 0;
uint public nextPunkIndexToAssign = 0;


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


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


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


struct Offer {
struct Offer {
bool isForSale;
bool isForSale;
uint punkIndex;
uint punkIndex;
address seller;
address seller;
uint minValue; // in ether
uint minValue; // in ether
address onlySellTo; // specify to sell only to a specific person
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
// 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 (uint => Offer) public punksOfferedForSale;


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

mapping (address => uint) public pendingWithdrawals;
mapping (address => uint) public pendingWithdrawals;


event Assign(address indexed to, uint256 punkIndex);
event Assign(address indexed to, uint256 punkIndex);
event Transfer(address indexed from, address indexed to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event PunkTransfer(address indexed from, address indexed to, uint256 punkIndex);
event PunkTransfer(address indexed from, address indexed to, uint256 punkIndex);
event PunkOffered(uint indexed punkIndex, uint minValue, address indexed toAddress);
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 PunkBought(uint indexed punkIndex, uint value, address indexed fromAddress, address indexed toAddress);
event PunkNoLongerForSale(uint indexed punkIndex);
event PunkNoLongerForSale(uint indexed punkIndex);


/* Initializes contract with initial supply tokens to the creator of the contract */
/* 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
// balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens
owner = msg.sender;
owner = msg.sender;
totalSupply = 10000; // Update total supply
totalSupply = 10000; // Update total supply
punksRemainingToAssign = totalSupply;
punksRemainingToAssign = totalSupply;
numberOfPunksToReserve = 1000;
name = "CRYPTOPUNKS"; // Set the name for display purposes
name = "CRYPTOPUNKS"; // Set the name for display purposes
symbol = "Ͼ"; // Set the symbol for display purposes
symbol = "Ͼ"; // Set the symbol for display purposes
decimals = 0; // Amount of decimals 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 (allPunksAssigned) throw;
if (punkIndex >= 10000) throw;
if (punkIndexToAddress[punkIndex] != to) {
if (punkIndexToAddress[punkIndex] != 0x0) {
balanceOf[punkIndexToAddress[punkIndex]]--;
} else {
punksRemainingToAssign--;
}
punkIndexToAddress[punkIndex] = to;
balanceOf[to]++;
Assign(to, punkIndex);
}
}

function setInitialOwners(address[] addresses, uint[] indices) {
if (msg.sender != owner) throw;
if (msg.sender != owner) throw;
if (numberOfPunksReserved >= numberOfPunksToReserve) throw;
uint n = addresses.length;
uint numberPunksReservedThisRun = 0;
for (uint i = 0; i < n; i++) {
while (numberOfPunksReserved < numberOfPunksToReserve && numberPunksReservedThisRun < maxForThisRun) {
setInitialOwner(addresses[i], indices[i]);
punkIndexToAddress[nextPunkIndexToAssign] = msg.sender;
Assign(msg.sender, nextPunkIndexToAssign);
numberPunksReservedThisRun++;
nextPunkIndexToAssign++;
}
}
punksRemainingToAssign -= numberPunksReservedThisRun;
}
numberOfPunksReserved += numberPunksReservedThisRun;

balanceOf[msg.sender] += numberPunksReservedThisRun;
function allInitialOwnersAssigned() {
if (msg.sender != owner) throw;
allPunksAssigned = true;
}
}


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


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


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


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


function buyPunk(uint punkIndex) payable {
function buyPunk(uint punkIndex) payable {
if (!allPunksAssigned) throw;
Offer offer = punksOfferedForSale[punkIndex];
Offer offer = punksOfferedForSale[punkIndex];
if (punkIndex >= 10000) throw;
if (!offer.isForSale) throw; // punk not actually for sale
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 (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 (msg.value < offer.minValue) throw; // Didn't send enough ETH
if (offer.seller != punkIndexToAddress[punkIndex]) throw; // Seller no longer owner of punk
if (offer.seller != punkIndexToAddress[punkIndex]) throw; // Seller no longer owner of punk


address seller = offer.seller;

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


punkNoLongerForSale(punkIndex);
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() {
function withdraw() {
if (!allPunksAssigned) throw;
uint amount = pendingWithdrawals[msg.sender];
uint amount = pendingWithdrawals[msg.sender];
// Remember to zero the pending refund before
// Remember to zero the pending refund before
// sending to prevent re-entrancy attacks
// sending to prevent re-entrancy attacks
pendingWithdrawals[msg.sender] = 0;
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
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);
}

}
}