|
// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023. |
|
|
|
// SPDX-License-Identifier: MIT
|
|
pragma solidity >=0.8.0;
|
|
|
|
/// @notice Minimalist and gas efficient standard ERC1155 implementation.
|
|
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC1155.sol)
|
|
abstract contract ERC1155 {
|
|
/*//////////////////////////////////////////////////////////////
|
|
EVENTS
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
event TransferSingle(
|
|
address indexed operator,
|
|
address indexed from,
|
|
address indexed to,
|
|
uint256 id,
|
|
uint256 amount
|
|
);
|
|
|
|
event TransferBatch(
|
|
address indexed operator,
|
|
address indexed from,
|
|
address indexed to,
|
|
uint256[] ids,
|
|
uint256[] amounts
|
|
);
|
|
|
|
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
|
|
|
|
event URI(string value, uint256 indexed id);
|
|
|
|
/*//////////////////////////////////////////////////////////////
|
|
ERC1155 STORAGE
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
mapping(address => mapping(uint256 => uint256)) public balanceOf;
|
|
|
|
mapping(address => mapping(address => bool)) public isApprovedForAll;
|
|
|
|
/*//////////////////////////////////////////////////////////////
|
|
METADATA LOGIC
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
function uri(uint256 id) public view virtual returns (string memory);
|
|
|
|
/*//////////////////////////////////////////////////////////////
|
|
ERC1155 LOGIC
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
function setApprovalForAll(address operator, bool approved) public virtual {
|
|
isApprovedForAll[msg.sender][operator] = approved;
|
|
|
|
emit ApprovalForAll(msg.sender, operator, approved);
|
|
}
|
|
|
|
function safeTransferFrom(
|
|
address from,
|
|
address to,
|
|
uint256 id,
|
|
uint256 amount,
|
|
bytes calldata data
|
|
) public virtual {
|
|
require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");
|
|
|
|
balanceOf[from][id] -= amount;
|
|
balanceOf[to][id] += amount;
|
|
|
|
emit TransferSingle(msg.sender, from, to, id, amount);
|
|
|
|
if (to.code.length != 0) {
|
|
require(
|
|
ERC1155TokenReceiver(to).onERC1155Received(msg.sender, from, id, amount, data) ==
|
|
ERC1155TokenReceiver.onERC1155Received.selector,
|
|
"UNSAFE_RECIPIENT"
|
|
);
|
|
} else require(to != address(0), "INVALID_RECIPIENT");
|
|
}
|
|
|
|
function safeBatchTransferFrom(
|
|
address from,
|
|
address to,
|
|
uint256[] calldata ids,
|
|
uint256[] calldata amounts,
|
|
bytes calldata data
|
|
) public virtual {
|
|
require(ids.length == amounts.length, "LENGTH_MISMATCH");
|
|
|
|
require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");
|
|
|
|
// Storing these outside the loop saves ~15 gas per iteration.
|
|
uint256 id;
|
|
uint256 amount;
|
|
|
|
for (uint256 i = 0; i < ids.length; ) {
|
|
id = ids[i];
|
|
amount = amounts[i];
|
|
|
|
balanceOf[from][id] -= amount;
|
|
balanceOf[to][id] += amount;
|
|
|
|
// An array can't have a total length
|
|
// larger than the max uint256 value.
|
|
unchecked {
|
|
++i;
|
|
}
|
|
}
|
|
|
|
emit TransferBatch(msg.sender, from, to, ids, amounts);
|
|
|
|
if (to.code.length != 0) {
|
|
require(
|
|
ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data) ==
|
|
ERC1155TokenReceiver.onERC1155BatchReceived.selector,
|
|
"UNSAFE_RECIPIENT"
|
|
);
|
|
} else require(to != address(0), "INVALID_RECIPIENT");
|
|
}
|
|
|
|
function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
|
|
public
|
|
view
|
|
virtual
|
|
returns (uint256[] memory balances)
|
|
{
|
|
require(owners.length == ids.length, "LENGTH_MISMATCH");
|
|
|
|
balances = new uint256[](owners.length);
|
|
|
|
// Unchecked because the only math done is incrementing
|
|
// the array index counter which cannot possibly overflow.
|
|
unchecked {
|
|
for (uint256 i = 0; i < owners.length; ++i) {
|
|
balances[i] = balanceOf[owners[i]][ids[i]];
|
|
}
|
|
}
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////
|
|
ERC165 LOGIC
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
|
|
return
|
|
interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
|
|
interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
|
|
interfaceId == 0x0e89341c; // ERC165 Interface ID for ERC1155MetadataURI
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////
|
|
INTERNAL MINT/BURN LOGIC
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
function _mint(
|
|
address to,
|
|
uint256 id,
|
|
uint256 amount,
|
|
bytes memory data
|
|
) internal virtual {
|
|
balanceOf[to][id] += amount;
|
|
|
|
emit TransferSingle(msg.sender, address(0), to, id, amount);
|
|
|
|
if (to.code.length != 0) {
|
|
require(
|
|
ERC1155TokenReceiver(to).onERC1155Received(msg.sender, address(0), id, amount, data) ==
|
|
ERC1155TokenReceiver.onERC1155Received.selector,
|
|
"UNSAFE_RECIPIENT"
|
|
);
|
|
} else require(to != address(0), "INVALID_RECIPIENT");
|
|
}
|
|
|
|
function _batchMint(
|
|
address to,
|
|
uint256[] memory ids,
|
|
uint256[] memory amounts,
|
|
bytes memory data
|
|
) internal virtual {
|
|
uint256 idsLength = ids.length; // Saves MLOADs.
|
|
|
|
require(idsLength == amounts.length, "LENGTH_MISMATCH");
|
|
|
|
for (uint256 i = 0; i < idsLength; ) {
|
|
balanceOf[to][ids[i]] += amounts[i];
|
|
|
|
// An array can't have a total length
|
|
// larger than the max uint256 value.
|
|
unchecked {
|
|
++i;
|
|
}
|
|
}
|
|
|
|
emit TransferBatch(msg.sender, address(0), to, ids, amounts);
|
|
|
|
if (to.code.length != 0) {
|
|
require(
|
|
ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, address(0), ids, amounts, data) ==
|
|
ERC1155TokenReceiver.onERC1155BatchReceived.selector,
|
|
"UNSAFE_RECIPIENT"
|
|
);
|
|
} else require(to != address(0), "INVALID_RECIPIENT");
|
|
}
|
|
|
|
function _batchBurn(
|
|
address from,
|
|
uint256[] memory ids,
|
|
uint256[] memory amounts
|
|
) internal virtual {
|
|
uint256 idsLength = ids.length; // Saves MLOADs.
|
|
|
|
require(idsLength == amounts.length, "LENGTH_MISMATCH");
|
|
|
|
for (uint256 i = 0; i < idsLength; ) {
|
|
balanceOf[from][ids[i]] -= amounts[i];
|
|
|
|
// An array can't have a total length
|
|
// larger than the max uint256 value.
|
|
unchecked {
|
|
++i;
|
|
}
|
|
}
|
|
|
|
emit TransferBatch(msg.sender, from, address(0), ids, amounts);
|
|
}
|
|
|
|
function _burn(
|
|
address from,
|
|
uint256 id,
|
|
uint256 amount
|
|
) internal virtual {
|
|
balanceOf[from][id] -= amount;
|
|
|
|
emit TransferSingle(msg.sender, from, address(0), id, amount);
|
|
}
|
|
}
|
|
|
|
/// @notice A generic interface for a contract which properly accepts ERC1155 tokens.
|
|
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/tokens/ERC1155.sol)
|
|
abstract contract ERC1155TokenReceiver {
|
|
function onERC1155Received(
|
|
address,
|
|
address,
|
|
uint256,
|
|
uint256,
|
|
bytes calldata
|
|
) external virtual returns (bytes4) {
|
|
return ERC1155TokenReceiver.onERC1155Received.selector;
|
|
}
|
|
|
|
function onERC1155BatchReceived(
|
|
address,
|
|
address,
|
|
uint256[] calldata,
|
|
uint256[] calldata,
|
|
bytes calldata
|
|
) external virtual returns (bytes4) {
|
|
return ERC1155TokenReceiver.onERC1155BatchReceived.selector;
|
|
}
|
|
}
|
|
|
|
/// @notice Simple single owner authorization mixin.
|
|
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/auth/Owned.sol)
|
|
abstract contract Owned {
|
|
/*//////////////////////////////////////////////////////////////
|
|
EVENTS
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
event OwnerUpdated(address indexed user, address indexed newOwner);
|
|
|
|
/*//////////////////////////////////////////////////////////////
|
|
OWNERSHIP STORAGE
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
address public owner;
|
|
|
|
modifier onlyOwner() virtual {
|
|
require(msg.sender == owner, "UNAUTHORIZED");
|
|
|
|
_;
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////
|
|
CONSTRUCTOR
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
constructor(address _owner) {
|
|
owner = _owner;
|
|
|
|
emit OwnerUpdated(address(0), _owner);
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////
|
|
OWNERSHIP LOGIC
|
|
//////////////////////////////////////////////////////////////*/
|
|
|
|
function setOwner(address newOwner) public virtual onlyOwner {
|
|
owner = newOwner;
|
|
|
|
emit OwnerUpdated(msg.sender, newOwner);
|
|
}
|
|
}
|
|
|
|
/// @notice Contract that enables a single call to call multiple methods on itself.
|
|
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Multicallable.sol)
|
|
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/Multicallable.sol)
|
|
/// @dev WARNING!
|
|
/// Multicallable is NOT SAFE for use in contracts with checks / requires on `msg.value`
|
|
/// (e.g. in NFT minting / auction contracts) without a suitable nonce mechanism.
|
|
/// It WILL open up your contract to double-spend vulnerabilities / exploits.
|
|
/// See: (https://www.paradigm.xyz/2021/08/two-rights-might-make-a-wrong/)
|
|
abstract contract Multicallable {
|
|
function multicall(bytes[] calldata data) public payable returns (bytes[] memory results) {
|
|
assembly {
|
|
if data.length {
|
|
results := mload(0x40) // Point `results` to start of free memory.
|
|
mstore(results, data.length) // Store `data.length` into `results`.
|
|
results := add(results, 0x20)
|
|
|
|
// `shl` 5 is equivalent to multiplying by 0x20.
|
|
let end := shl(5, data.length)
|
|
// Copy the offsets from calldata into memory.
|
|
calldatacopy(results, data.offset, end)
|
|
// Pointer to the top of the memory (i.e. start of the free memory).
|
|
let memPtr := add(results, end)
|
|
end := add(results, end)
|
|
|
|
// prettier-ignore
|
|
for {} 1 {} {
|
|
// The offset of the current bytes in the calldata.
|
|
let o := add(data.offset, mload(results))
|
|
// Copy the current bytes from calldata to the memory.
|
|
calldatacopy(
|
|
memPtr,
|
|
add(o, 0x20), // The offset of the current bytes' bytes.
|
|
calldataload(o) // The length of the current bytes.
|
|
)
|
|
if iszero(delegatecall(gas(), address(), memPtr, calldataload(o), 0x00, 0x00)) {
|
|
// Bubble up the revert if the delegatecall reverts.
|
|
returndatacopy(0x00, 0x00, returndatasize())
|
|
revert(0x00, returndatasize())
|
|
}
|
|
// Append the current `memPtr` into `results`.
|
|
mstore(results, memPtr)
|
|
results := add(results, 0x20)
|
|
// Append the `returndatasize()`, and the return data.
|
|
mstore(memPtr, returndatasize())
|
|
returndatacopy(add(memPtr, 0x20), 0x00, returndatasize())
|
|
// Advance the `memPtr` by `returndatasize() + 0x20`,
|
|
// rounded up to the next multiple of 32.
|
|
memPtr := and(add(add(memPtr, returndatasize()), 0x3f), 0xffffffffffffffe0)
|
|
// prettier-ignore
|
|
if iszero(lt(results, end)) { break }
|
|
}
|
|
// Restore `results` and allocate memory for it.
|
|
results := mload(0x40)
|
|
mstore(0x40, memPtr)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// @notice SolDAO ERC1155 implementation.
|
|
/// @author SolDAO (https://github.com/Sol-DAO/governance/blob/main/src/SolDAO.sol)
|
|
contract SolDAO is
|
|
ERC1155,
|
|
Owned(tx.origin),
|
|
Multicallable
|
|
{
|
|
event SetBaseURI(string baseURI);
|
|
|
|
event SetURIfetcher(ERC1155 indexed uriFetcher);
|
|
|
|
event SetTransferability(uint256 id, bool set);
|
|
|
|
string public constant name = "SolDAO";
|
|
|
|
string public constant symbol = "SOLD";
|
|
|
|
string public baseURI;
|
|
|
|
ERC1155 public uriFetcher;
|
|
|
|
mapping(uint256 => bool) public transferable;
|
|
|
|
function safeTransferFrom(
|
|
address from,
|
|
address to,
|
|
uint256 id,
|
|
uint256 amount,
|
|
bytes calldata data
|
|
) public override {
|
|
require(transferable[id], "NONTRANSFERABLE");
|
|
|
|
super.safeTransferFrom(from, to, id, amount, data);
|
|
}
|
|
|
|
function safeBatchTransferFrom(
|
|
address from,
|
|
address to,
|
|
uint256[] calldata ids,
|
|
uint256[] calldata amounts,
|
|
bytes calldata data
|
|
) public override {
|
|
for (uint256 i; i < ids.length; ) {
|
|
require(transferable[ids[i]], "NONTRANSFERABLE");
|
|
|
|
// An array can't have a total length
|
|
// larger than the max uint256 value.
|
|
unchecked {
|
|
++i;
|
|
}
|
|
}
|
|
|
|
super.safeBatchTransferFrom(from, to, ids, amounts, data);
|
|
}
|
|
|
|
function mint(
|
|
address to,
|
|
uint256 id,
|
|
uint256 amount,
|
|
bytes calldata data
|
|
) public payable onlyOwner {
|
|
_mint(to, id, amount, data);
|
|
}
|
|
|
|
function burn(
|
|
address from,
|
|
uint256 id,
|
|
uint256 amount
|
|
) public payable onlyOwner {
|
|
_burn(from, id, amount);
|
|
}
|
|
|
|
function uri(uint256 id) public view override returns (string memory) {
|
|
string memory base = baseURI;
|
|
|
|
if (bytes(base).length != 0) return string(abi.encodePacked(base, _toString(id)));
|
|
|
|
else return uriFetcher.uri(id);
|
|
}
|
|
|
|
function _toString(uint256 value) internal pure returns (string memory str) {
|
|
assembly {
|
|
// The maximum value of a uint256 contains 78 digits (1 byte per digit), but
|
|
// we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
|
|
// We will need 1 word for the trailing zeros padding, 1 word for the length,
|
|
// and 3 words for a maximum of 78 digits. Total: 5 * 0x20 = 0xa0.
|
|
let m := add(mload(0x40), 0xa0)
|
|
// Update the free memory pointer to allocate.
|
|
mstore(0x40, m)
|
|
// Assign the `str` to the end.
|
|
str := sub(m, 0x20)
|
|
// Zeroize the slot after the string.
|
|
mstore(str, 0)
|
|
|
|
// Cache the end of the memory to calculate the length later.
|
|
let end := str
|
|
|
|
// We write the string from rightmost digit to leftmost digit.
|
|
// The following is essentially a do-while loop that also handles the zero case.
|
|
// prettier-ignore
|
|
for { let temp := value } 1 {} {
|
|
str := sub(str, 1)
|
|
// Write the character to the pointer.
|
|
// The ASCII index of the '0' character is 48.
|
|
mstore8(str, add(48, mod(temp, 10)))
|
|
// Keep dividing `temp` until zero.
|
|
temp := div(temp, 10)
|
|
// prettier-ignore
|
|
if iszero(temp) { break }
|
|
}
|
|
|
|
let length := sub(end, str)
|
|
// Move the pointer 32 bytes leftwards to make room for the length.
|
|
str := sub(str, 0x20)
|
|
// Store the length.
|
|
mstore(str, length)
|
|
}
|
|
}
|
|
|
|
function setBaseURI(string calldata _baseURI) public payable onlyOwner {
|
|
baseURI = _baseURI;
|
|
|
|
emit SetBaseURI(_baseURI);
|
|
}
|
|
|
|
function setURIfetcher(ERC1155 _uriFetcher) public payable onlyOwner {
|
|
uriFetcher = _uriFetcher;
|
|
|
|
emit SetURIfetcher(_uriFetcher);
|
|
}
|
|
|
|
function setTransferability(uint256 id, bool set) public payable onlyOwner {
|
|
transferable[id] = set;
|
|
|
|
emit SetTransferability(id, set);
|
|
}
|
|
} |