文件 1 的 14：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
文件 2 的 14：Deed.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../resources/IResources.sol";
import "./IDeed.sol";
contract Deed is ERC721, IDeed, IERC1155Receiver, Ownable, ReentrancyGuard {
using Strings for uint256;
using EnumerableSet for EnumerableSet.UintSet;
uint256 private constant MAX_UINT64 = 0xFFFFFFFFFFFFFFFF;
address public immutable RESOURCES_ADDRESS;
uint256 private _currentTokenId;
bool private _mintEnabled;
string private _metadataDescription = "Loading...";
string private _metadataImageBaseURI = "https://deed.lvcidia.xyz/viewer/";
mapping(uint256 => ContributionState) private _contribution;
mapping(address => mapping(uint256 => uint256))
private _userContributionCount;
mapping(uint256 => mapping(uint256 => uint256))
private _deedContributionCount;
EnumerableSet.UintSet private _resources;
uint256 private _royaltyBps;
address payable private _royaltyRecipient;
bytes4 private constant _INTERFACE_ID_ROYALTIES_CREATORCORE = 0xbb3bafd6;
bytes4 private constant _INTERFACE_ID_ROYALTIES_EIP2981 = 0x2a55205a;
bytes4 private constant _INTERFACE_ID_ROYALTIES_RARIBLE = 0xb7799584;
constructor(address resourcesAddress) ERC721("LVCIDIA// DEED", "DEED") {
RESOURCES_ADDRESS = resourcesAddress;
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC721, IERC165) returns (bool) {
return
ERC721.supportsInterface(interfaceId) ||
interfaceId == _INTERFACE_ID_ROYALTIES_CREATORCORE ||
interfaceId == _INTERFACE_ID_ROYALTIES_EIP2981 ||
interfaceId == _INTERFACE_ID_ROYALTIES_RARIBLE;
}
function updateContribution(
uint256[] calldata resourceIds,
Contribution[] calldata resourceContributions
) external override onlyOwner {
require(
resourceIds.length == resourceContributions.length,
"Invalid input"
);
for (uint i = 0; i < resourceIds.length; ) {
Contribution memory contribution = resourceContributions[i];
_contribution[resourceIds[i]] = ContributionState({
name: contribution.name,
perUnit: contribution.perUnit,
maxUnits: contribution.maxUnits,
totalUnits: _contribution[resourceIds[i]].totalUnits
});
if (contribution.maxUnits == 0) {
_resources.remove(resourceIds[i]);
} else {
_resources.add(resourceIds[i]);
}
unchecked {
i++;
}
}
}
function getContributionState(
uint256 resourceId
) external view override returns (ContributionState memory) {
return _contribution[resourceId];
}
function getUserContributions(
address user
)
public
view
override
returns (
ContributionInfo[] memory contributions,
uint256 totalContributions
)
{
contributions = new ContributionInfo[](_resources.length());
for (uint i; i < _resources.length(); ) {
uint256 resourceId = _resources.at(i);
ContributionState memory contribution = _contribution[resourceId];
uint256 units = _userContributionCount[user][resourceId];
contributions[i] = ContributionInfo({
resourceId: resourceId,
resourceName: contribution.name,
units: units,
perUnit: contribution.perUnit
});
totalContributions += units;
unchecked {
++i;
}
}
}
function getDeedContributions(
uint256 tokenId
)
public
view
override
returns (
ContributionInfo[] memory contributions,
uint256 totalContributions
)
{
contributions = new ContributionInfo[](_resources.length());
for (uint i; i < _resources.length(); ) {
uint256 resourceId = _resources.at(i);
contributions[i] = ContributionInfo({
resourceId: resourceId,
resourceName: _contribution[resourceId].name,
units: _deedContributionCount[tokenId][resourceId],
perUnit: _contribution[resourceId].perUnit
});
totalContributions += _deedContributionCount[tokenId][resourceId];
unchecked {
++i;
}
}
}
function setMintEnabled(bool enabled) external override onlyOwner {
require(enabled != _mintEnabled, "should be a different value");
_mintEnabled = enabled;
}
function mint() external override {
if (!_mintEnabled) revert("Mint not open yet");
uint256 tokenId = ++_currentTokenId;
bool hasContributed = false;
for (uint i = 0; i < _resources.length(); ) {
uint256 resourceId = _resources.at(i);
uint256 userContribution = _userContributionCount[msg.sender][
resourceId
];
_deedContributionCount[tokenId][resourceId] = userContribution;
_userContributionCount[msg.sender][resourceId] = 0;
if (
_deedContributionCount[tokenId][resourceId] > 0 &&
!hasContributed
) {
hasContributed = true;
}
unchecked {
i++;
}
}
require(hasContributed, "No contributions yet");
_mint(msg.sender, tokenId);
}
function merge(uint256[] calldata tokenIds) external override nonReentrant {
uint256 newToken = ++_currentTokenId;
uint256 resourcesLength = _resources.length();
uint256 tokensLength = tokenIds.length;
require(
tokenIds.length > 1,
"At least two tokens are required for merging"
);
for (uint i = 0; i < tokensLength; ) {
uint256 tokenId = tokenIds[i];
require(_exists(tokenId), "Nonexistent or duplicated token");
require(ownerOf(tokenId) == msg.sender, "Not owner");
for (uint j = 0; j < resourcesLength; ) {
uint256 resourceId = _resources.at(j);
uint256 contribution = _deedContributionCount[tokenId][
resourceId
];
if (contribution > 0) {
delete _deedContributionCount[tokenId][resourceId];
}
_deedContributionCount[newToken][resourceId] += contribution;
unchecked {
j++;
}
}
_burn(tokenId);
unchecked {
i++;
}
}
_mint(msg.sender, newToken);
}
function split(
uint256 tokenA,
uint256[] calldata tokenBUnits
) external override nonReentrant {
require(_exists(tokenA), "Nonexistent token");
require(ownerOf(tokenA) == msg.sender, "Not owner");
uint256 resourcesLength = _resources.length();
require(
tokenBUnits.length == resourcesLength,
"Invalid ressources info"
);
uint256 tokenB = ++_currentTokenId;
uint256 tokenC = ++_currentTokenId;
bool hasContributionsB;
bool hasContributionsC;
for (uint i = 0; i < resourcesLength; ) {
uint256 resourceId = _resources.at(i);
uint256 contributionA = _deedContributionCount[tokenA][resourceId];
uint256 contributionB = tokenBUnits[i];
require(
contributionA >= contributionB,
"Not enough resources to split"
);
uint256 contributionC = contributionA - tokenBUnits[i];
if (contributionA > 0) {
delete _deedContributionCount[tokenA][resourceId];
}
_deedContributionCount[tokenB][resourceId] = contributionB;
_deedContributionCount[tokenC][resourceId] = contributionC;
if (contributionB > 0) hasContributionsB = true;
if (contributionC > 0) hasContributionsC = true;
unchecked {
i++;
}
}
require(
hasContributionsB && hasContributionsC,
"A new deed must have contributions"
);
_burn(tokenA);
_mint(msg.sender, tokenB);
_mint(msg.sender, tokenC);
}
function onERC1155Received(
address,
address from,
uint256 id,
uint256 value,
bytes calldata
) external override returns (bytes4) {
require(!_mintEnabled, "Cannot contribute anymore");
ContributionState storage contribution = _contribution[id];
require(
msg.sender == RESOURCES_ADDRESS && contribution.maxUnits > 0,
"Invalid resource"
);
uint256 unitsAvailable = contribution.maxUnits -
contribution.totalUnits;
require(unitsAvailable > 0, "Contribution limit reached");
require(value % contribution.perUnit == 0, "Invalid amount");
uint256 unitsRequested = value / contribution.perUnit;
uint256 units;
if (unitsRequested > unitsAvailable) {
units = unitsAvailable;
} else {
units = unitsRequested;
}
require(units > 0 && units <= MAX_UINT64, "Invalid units");
_userContributionCount[from][id] += units;
emit Contribute(id, from, uint64(units));
contribution.totalUnits += uint64(units);
uint256[] memory resourceIds = new uint256[](1);
resourceIds[0] = id;
uint256[] memory amounts = new uint256[](1);
amounts[0] = units * contribution.perUnit;
IResources(RESOURCES_ADDRESS).burn(address(this), resourceIds, amounts);
if (units != unitsRequested) {
IResources(RESOURCES_ADDRESS).safeTransferFrom(
address(this),
from,
id,
(unitsRequested - units) * contribution.perUnit,
""
);
}
return this.onERC1155Received.selector;
}
function onERC1155BatchReceived(
address,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata
) external override returns (bytes4) {
require(!_mintEnabled, "Cannot contribute anymore");
uint256 resourceLength = ids.length;
require(
msg.sender == RESOURCES_ADDRESS && resourceLength == values.length,
"Invalid resource"
);
bool hasContribution = false;
bool hasExcess = false;
uint256[] memory refundAmounts = new uint256[](resourceLength);
uint256[] memory burnAmounts = new uint256[](resourceLength);
for (uint i = 0; i < resourceLength; i++) {
ContributionState storage contribution = _contribution[ids[i]];
uint256 unitsAvailable = contribution.maxUnits -
contribution.totalUnits;
if (unitsAvailable == 0 || values[i] % contribution.perUnit != 0) {
hasExcess = true;
refundAmounts[i] = values[i];
continue;
}
uint256 unitsRequested = values[i] / contribution.perUnit;
uint256 units;
if (unitsRequested > unitsAvailable) {
units = unitsAvailable;
} else {
units = unitsRequested;
}
require(units <= MAX_UINT64, "Invalid amount");
_userContributionCount[from][ids[i]] += units;
emit Contribute(ids[i], from, uint64(units));
contribution.totalUnits += uint64(units);
burnAmounts[i] = units * contribution.perUnit;
hasContribution = true;
if (units != unitsRequested) {
hasExcess = true;
refundAmounts[i] =
(unitsRequested - units) *
contribution.perUnit;
}
}
IResources(RESOURCES_ADDRESS).burn(address(this), ids, burnAmounts);
if (hasExcess) {
IResources(RESOURCES_ADDRESS).safeBatchTransferFrom(
address(this),
from,
ids,
refundAmounts,
""
);
}
return this.onERC1155BatchReceived.selector;
}
function setMetadata(
string calldata description,
string calldata imageBaseURI
) external override onlyOwner {
if (bytes(description).length > 0) _metadataDescription = description;
if (bytes(imageBaseURI).length > 0)
_metadataImageBaseURI = imageBaseURI;
}
function tokenURI(
uint256 tokenId
) public view virtual override returns (string memory) {
require(
_exists(tokenId),
"ERC721Metadata: URI query for nonexistent token"
);
(
ContributionInfo[] memory contributions,
uint256 totalContributions
) = getDeedContributions(tokenId);
string memory traits;
traits = string(
abi.encodePacked(
traits,
'{"trait_type":"Planet Ownership","value":"',
_unitToPercentage(totalContributions),
'%"},'
)
);
traits = string(
abi.encodePacked(
traits,
'{"trait_type":"Background Material","value":"',
_getDeedMaterial(totalContributions, false),
'"}'
)
);
for (uint i = 0; i < _resources.length(); ) {
string memory activated;
contributions[i].units > 0 ? activated = "YES" : activated = "NO";
traits = string(
abi.encodePacked(
traits,
',{"trait_type":"',
contributions[i].resourceName,
'","value":"',
activated,
'"}'
)
);
unchecked {
i++;
}
}
for (uint i = 0; i < _resources.length(); ) {
traits = string(
abi.encodePacked(
traits,
',{"trait_type":"',
contributions[i].resourceName,
'","value":',
(contributions[i].units * contributions[i].perUnit)
.toString(),
"}"
)
);
unchecked {
i++;
}
}
return
string(
abi.encodePacked(
"data:application/json;utf8,",
'{"name":"',
_getDeedMaterial(totalContributions, true),
" DEED// #",
tokenId.toString(),
'","created_by":"LVCIDIA","description":"',
_metadataDescription,
'","image":"',
_metadataImageBaseURI,
tokenId.toString(),
'.png","attributes":[',
traits,
"]}"
)
);
}
function _unitToPercentage(
uint256 unit
) private pure returns (string memory) {
string memory result = Strings.toString(unit / 1000);
string memory decimal = Strings.toString(unit % 1000);
while (bytes(decimal).length < 3) {
decimal = string(abi.encodePacked("0", decimal));
}
result = string(abi.encodePacked(result, ".", decimal));
return result;
}
function _getDeedMaterial(
uint256 totalContributions,
bool caps
) private pure returns (string memory) {
if (totalContributions < 10) {
if (caps) {
return "BLACK";
} else {
return "Black";
}
} else if (totalContributions < 50) {
if (caps) {
return "MARBLE";
} else {
return "Marble";
}
} else if (totalContributions < 200) {
if (caps) {
return "CHROME";
} else {
return "Chrome";
}
} else if (totalContributions < 1000) {
if (caps) {
return "JADE";
} else {
return "Jade";
}
} else {
if (caps) {
return "GOLD";
} else {
return "Gold";
}
}
}
function updateRoyalties(
address payable recipient,
uint256 bps
) external onlyOwner {
_royaltyRecipient = recipient;
_royaltyBps = bps;
}
function getRoyalties(
uint256
)
external
view
returns (address payable[] memory recipients, uint256[] memory bps)
{
if (_royaltyRecipient != address(0x0)) {
recipients = new address payable[](1);
recipients[0] = _royaltyRecipient;
bps = new uint256[](1);
bps[0] = _royaltyBps;
}
return (recipients, bps);
}
function getFeeRecipients(
uint256
) external view returns (address payable[] memory recipients) {
if (_royaltyRecipient != address(0x0)) {
recipients = new address payable[](1);
recipients[0] = _royaltyRecipient;
}
return recipients;
}
function getFeeBps(uint256) external view returns (uint[] memory bps) {
if (_royaltyRecipient != address(0x0)) {
bps = new uint256[](1);
bps[0] = _royaltyBps;
}
return bps;
}
function royaltyInfo(
uint256,
uint256 value
) external view returns (address, uint256) {
return (_royaltyRecipient, (value * _royaltyBps) / 10000);
}
}
文件 3 的 14：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 4 的 14：EnumerableSet.sol
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
文件 5 的 14：IDeed.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
interface IDeed is IERC165 {
event Contribute(
uint256 indexed resourceId,
address indexed contributor,
uint64 units
);
struct Contribution {
string name;
uint64 perUnit;
uint64 maxUnits;
}
struct ContributionState {
string name;
uint64 perUnit;
uint64 maxUnits;
uint64 totalUnits;
}
struct UserContribution {
uint256 resourceId;
uint256 units;
}
struct DeedContribution {
uint256 resourceId;
uint256 units;
}
struct ContributionInfo {
uint256 resourceId;
string resourceName;
uint256 units;
uint64 perUnit;
}
function updateContribution(
uint256[] calldata resourceIds,
Contribution[] calldata resourceContributions
) external;
function getContributionState(
uint256 resourceId
) external returns (ContributionState memory);
function getUserContributions(
address user
)
external
returns (
ContributionInfo[] memory contributions,
uint256 totalContributions
);
function getDeedContributions(
uint256 tokenId
)
external
returns (
ContributionInfo[] memory contributions,
uint256 totalContributions
);
function setMintEnabled(bool enabled) external;
function mint() external;
function split(uint256 tokenA, uint256[] calldata tokenBUnits) external;
function merge(uint256[] calldata tokenIds) external;
function setMetadata(
string calldata description,
string calldata imageBaseURI
) external;
}
文件 6 的 14：IERC1155.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
文件 7 的 14：IERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
文件 8 的 14：IERC721Metadata.sol
pragma solidity ^0.8.0;
import "../IERC721.sol";
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);
}
文件 9 的 14：IERC721Receiver.sol
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
文件 10 的 14：IResources.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
interface IResources is IERC1155 {
function mint(address to, uint256[] memory tokenIds, uint256[] memory amounts) external;
function setTokenURI(uint256 tokenId, string calldata uri_) external;
function setTokenURIs(uint256[] memory tokenIds, string[] calldata uris) external;
function burn(address account, uint256[] calldata tokenIds, uint256[] calldata amounts) external;
function totalSupply(uint256 tokenId) external view returns (uint256);
function burnedSupply(uint256 tokenId) external view returns (uint256);
}
文件 11 的 14：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1);
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
文件 12 的 14：Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 13 的 14：ReentrancyGuard.sol
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
}
文件 14 的 14：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
