File 1 of 1: Hashmarks.sol
abstract contract DataContract {
function data() external virtual view returns (bytes memory);
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
string private _name;
string private _symbol;
string internal _baseURI;
mapping(uint256 => string) internal _tokenURIs;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
if (bytes(_tokenURIs[tokenId]).length > 0) {
return _tokenURIs[tokenId];
}
return bytes(_baseURI).length > 0 ? string(abi.encodePacked(_baseURI, ToString.toString(tokenId))) : "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721.ownerOf(tokenId);
delete _tokenApprovals[tokenId];
unchecked {
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
delete _tokenApprovals[tokenId];
unchecked {
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
function __unsafe_increaseBalance(address account, uint256 amount) internal {
_balances[account] += amount;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
pragma solidity ^0.8.4;
library ToString {
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
bytes internal constant TABLE = "0123456789ABCDEF";
function toHex(uint256 val) internal pure returns (string memory) {
if (val==0) return "00";
bytes memory buf = new bytes(2);
buf[1] = TABLE[val & 0xf];
buf[0] = TABLE[val >> 4 & 0xf];
return string(buf);
}
}
library Base64 {
bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function encode(bytes memory data) internal pure returns (string memory) {
uint256 len = data.length;
if (len == 0) return "";
uint256 encodedLen = 4 * ((len + 2) / 3);
bytes memory result = new bytes(encodedLen + 32);
bytes memory table = TABLE;
assembly {
let tablePtr := add(table, 1)
let resultPtr := add(result, 32)
for {
let i := 0
} lt(i, len) {
} {
i := add(i, 3)
let input := and(mload(add(data, i)), 0xffffff)
let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(input, 0x3F))), 0xFF))
out := shl(224, out)
mstore(resultPtr, out)
resultPtr := add(resultPtr, 4)
}
switch mod(len, 3)
case 1 {
mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
}
case 2 {
mstore(sub(resultPtr, 1), shl(248, 0x3d))
}
mstore(result, encodedLen)
}
return string(result);
}
}
contract Hashmarks is ERC721 {
bool isSealed;
address _owner;
uint256 public constant max_hashes = 11;
uint256 public constant fade_period = (86400*365);
uint256 public constant grey_fade = 0xc0;
uint256 public constant reveal_window = (86400*2);
uint256 public constant safeguard_expire = 86400*180;
uint256 public deployed_ts;
uint256[100] fadeamounts;
uint256 numTokens;
struct TokenStruct {
bool claimed;
address claimer;
uint256 hindex;
bytes32[100] hashchain;
DataContract[2] paths;
uint256 last_refresh;
uint256 period;
bool immortal;
}
struct CommitStruct {
bytes32 hash;
uint256 ts;
}
event eRefresh(uint256 tid,uint256 hindex);
event eAscension(uint256 tid);
event eClaim(uint256 tid);
mapping(uint256 => TokenStruct) public tokens;
mapping(address => CommitStruct) public commits;
mapping(address => bool) public allow_commit;
mapping(bytes32 => bool) public allow_reveal;
modifier onlyInit() {
require(msg.sender==_owner && isSealed == false);
_;
}
modifier onlyOwner() {
require(msg.sender==_owner);
_;
}
constructor() ERC721("HASHMARKS", "HASHMARKS") {
deployed_ts = block.timestamp;
_owner = msg.sender;
}
function owner() public view virtual returns (address) {
return _owner;
}
function totalSupply() public view returns (uint256) {
return numTokens;
}
function walletOfOwner(address a) public view returns (uint256[] memory) {
uint256 ownerTokenCount = balanceOf(a);
uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount);
uint256 currentTokenId = 0;
uint256 ownedTokenIndex = 0;
while (ownedTokenIndex < ownerTokenCount && currentTokenId < 100) {
if (_exists(currentTokenId)) {
address currentTokenOwner = ownerOf(currentTokenId);
if (currentTokenOwner == a) {
ownedTokenIds[ownedTokenIndex] = currentTokenId;
ownedTokenIndex++;
}
}
currentTokenId++;
}
return ownedTokenIds;
}
function seal() public onlyOwner {
require(isSealed == false, "Already sealed.");
isSealed = true;
}
function initHashes(uint256[] memory tid, bytes32[] memory a) public onlyInit {
for (uint256 i = 0;i<tid.length;i++) {
tokens[tid[i]].hashchain[0] = a[i];
}
}
function safeguard_commit(address[] memory a, bool v) public onlyInit {
for (uint256 i = 0;i<a.length;i++)
allow_commit[a[i]] = v;
}
function safeguard_reveal(address[] memory a, uint256[] memory tid, bool v) public onlyInit {
for (uint256 i = 0;i<tid.length;i++)
allow_reveal[keccak256(abi.encodePacked(a[i],tid[i]))] = v;
}
function tokenInfo(uint256 tid) public view returns(address[] memory paths, bytes32[] memory hashchain) {
address[] memory plist = new address[](2);
plist[0] = address(tokens[tid].paths[0]);
plist[1] = address(tokens[tid].paths[1]);
paths = plist;
bytes32[] memory rlist = new bytes32[](11);
for (uint256 k=0;k<11;k++) {
rlist[k]=tokens[tid].hashchain[k];
}
hashchain = rlist;
}
function is_allow_reveal(address a) public view returns (uint256[] memory) {
uint k=0;
for (uint256 tid=0;tid<100;tid++)
if (allow_reveal[keccak256(abi.encodePacked(a,tid))]) k++;
uint256[] memory rlist = new uint256[](k);
k=0;
for (uint256 tid=0;tid<100;tid++) {
if (allow_reveal[keccak256(abi.encodePacked(a,tid))]) {
rlist[k]=tid;
k++;
}
}
return rlist;
}
function iToHex(bytes memory buffer) public pure returns (string memory) {
bytes memory converted = new bytes(buffer.length * 2);
bytes memory _base = "0123456789abcdef";
for (uint256 i = 0; i < buffer.length; i++) {
converted[i * 2] = _base[uint8(buffer[i]) / _base.length];
converted[i * 2 + 1] = _base[uint8(buffer[i]) % _base.length];
}
return string(abi.encodePacked("0x", converted));
}
function initData(uint256[] memory tid, uint256[] memory ind, address[] memory a) public onlyInit {
for (uint256 i = 0;i<tid.length;i++) {
tokens[tid[i]].paths[ind[i]] = DataContract(a[i]);
}
}
function commit(bytes32 a) public {
require(allow_commit[msg.sender] || block.timestamp > deployed_ts + safeguard_expire, "Safeguard: msg.sender not on temporary allow list");
commits[msg.sender].hash = a;
commits[msg.sender].ts = block.timestamp;
}
function getCommit(address a) public view returns (bytes32 hash, uint256 ts) {
return (commits[a].hash, commits[a].ts);
}
function reveal(uint8 tid, bytes32 solution, string memory salt) public {
require(tid < 100,"token ID out of range");
require(!tokens[tid].claimed,"token ID already claimed");
require(allow_reveal[keccak256(abi.encodePacked(msg.sender,uint256(tid)))] || block.timestamp > deployed_ts + safeguard_expire, "Safeguard: (address,tokenid) pair not on temporary allow list");
address i = msg.sender;
require(commits[i].ts > 0, "No commit has been made for this address");
require(block.timestamp - commits[i].ts > reveal_window, "need 48hr between commit and reveal");
bytes32 b = keccak256(abi.encodePacked(bytes1(tid), msg.sender, solution, salt));
require(b==commits[i].hash, "Commit hash doesn't match");
require(keccak256(abi.encodePacked(solution))==tokens[tid].hashchain[0],"Invalid solution");
tokens[tid].last_refresh = block.timestamp;
tokens[tid].period = fade_period;
tokens[tid].claimed = true;
tokens[tid].hindex++;
tokens[tid].hashchain[tokens[tid].hindex] = solution;
_mint(msg.sender, tid);
tokens[tid].claimer = msg.sender;
numTokens++;
emit eClaim(tid);
}
function refresh(uint256 tid, bytes32 solution) public {
require(tid < 100, "tid out of range");
require(tokens[tid].claimed,"Token not yet claimed");
require(!tokens[tid].immortal,"maximum refreshes exceeded");
require(block.timestamp > tokens[tid].last_refresh + tokens[tid].period, "Must wait till period expires to refresh");
require(keccak256(abi.encodePacked(solution)) == tokens[tid].hashchain[tokens[tid].hindex], "Incorrect hash");
tokens[tid].hindex++;
tokens[tid].last_refresh = block.timestamp;
tokens[tid].hashchain[tokens[tid].hindex] = solution;
emit eRefresh(tid,tokens[tid].hindex);
if (tokens[tid].hindex>=max_hashes) {
tokens[tid].immortal = true;
emit eAscension(tid);
}
}
function fade_amount(uint256 tid) public view returns (uint256) {
if (fadeamounts[tid] > 0) return fadeamounts[tid];
uint256 c = tokens[tid].last_refresh + tokens[tid].period;
uint256 am = 0;
if (tokens[tid].immortal) {
} else if (block.timestamp <= c || tokens[tid].claimed==false) {
} else {
am = ((block.timestamp - c)*100) / tokens[tid].period;
if (am > 100 ) am = 100;
uint256 iam = (100-am);
am = 100 - ((iam*iam)/100);
}
return am;
}
function getSVG(uint256 tid) public view returns (string memory) {
require(tid < 100, "Token ID out of range");
uint256 am = fade_amount(tid);
uint256 fill = 255;
fill = fill * (100-am) + grey_fade * am;
fill /= 100;
string memory hexcol = ToString.toHex(fill);
string memory p1 = string(abi.encodePacked('<svg preserveAspectRatio="xMinYMin meet" version="1.1" viewBox="0 0 96 96" xmlns="http://www.w3.org/2000/svg"> <g stroke-width=".32"> <rect width="100%" height="100%" fill="#',hexcol,hexcol,hexcol,'" />'));
string memory p2 = '</g></svg>';
uint256 num_paths = 2;
uint256[2] memory path_fills = [uint256(85*2),85];
string memory res;
for (uint pi=0;pi<num_paths;pi++) {
bytes memory s = tokens[tid].paths[pi].data();
string memory svg_path;
bytes32 h = tokens[tid].hashchain[1];
if (h == 0x0) {
svg_path = string(s); }
else {
svg_path = decrypt(s,h);
}
fill = path_fills[pi];
fill = fill * (100-am) + grey_fade * am;
fill /= 100;
hexcol = ToString.toHex(fill);
res = string(abi.encodePacked(res,"<path d=\"",svg_path,"\" style=\"fill:#",hexcol,hexcol,hexcol,";stroke-width:0.32\" />\n"));
}
res = string(abi.encodePacked(p1,res,p2));
return res;
}
function decrypt(bytes memory s, bytes32 h) public pure returns (string memory) {
bytes32 m;
uint256 j = 0;
assembly {
j := s
}
for (uint i=0;i<s.length/32;i++) {
h = keccak256(abi.encodePacked(h,i));
assembly {
j := add(j,32)
m := mload(j)
mstore(j,xor(m,h))
}
}
return string(s);
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
_requireMinted(tokenId);
string memory svg = getSVG(tokenId);
uint256 refreshes = tokens[tokenId].hindex - 1;
uint256 fa = fade_amount(tokenId);
string memory attributes = string(abi.encodePacked(", \"attributes\": [ {\"trait_type\": \"Refreshes\", \"value\": \"",ToString.toString(refreshes),"\"}"));
if (tokens[tokenId].immortal) attributes = string(abi.encodePacked(attributes,", {\"trait_type\": \"Immortal\", \"value\": \"Immortal\"}"));
if (fa > 0) attributes = string(abi.encodePacked(attributes,", {\"trait_type\": \"Fade\", \"value\": \"",ToString.toString(fa),"\"}"));
attributes = string(abi.encodePacked(attributes,"]"));
string memory json = Base64.encode(bytes(string(abi.encodePacked('{"name": "HASHMARKS #', ToString.toString(tokenId), '", "description": "HASHMARKS by 0xDEAFBEEF: 100 unique hand forged iron sculptures and cryptographically linked digital tokens."', attributes, ', "image": "data:image/svg+xml;base64,', Base64.encode(bytes(svg)), '"}'))));
return string(abi.encodePacked('data:application/json;base64,', json));
}
}
