Source Code
Overview
ETH Balance
0 ETH
ETH Value
$0.00Token Holdings
- ERC-20 Tokens (1)View All Holdings1.052086 USDC
USD Coin (USDC)$1.05@0.9996
Multichain Info
2 addresses found via
| Transaction Hash |
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
Cross-Chain Transactions
Loading...
Loading
Contract Name:
CoreIssuerV3
Compiler Version
v0.8.19+commit.7dd6d404
Optimization Enabled:
Yes with 1000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {AccountBoundToken} from "../AccountBoundToken.sol";
import "solmate/src/utils/MerkleProofLib.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
struct SBTAirdropData {
address receiver;
string id;
string credentialURL;
bytes32[] proof;
}
struct Project {
address projectOwner;
uint256 tokenId;
string id;
bytes32 root;
uint256 fee;
}
error InvalidMerkleProof(
address receiver,
string id,
string credentialURL,
bytes32[] proof
);
error InvalidSignature();
error ProjectHasNoRoot(string id);
error InvalidSigner(address signer, address receiver);
error ReceiverNotOwner();
error WithdrawAddressNotSet();
error InsufficientFee();
error ProjectAlreadyExist();
error ProjectNotExist();
error CallerNotProjectOwner();
// _________ .__ .__ _________ .___
// \_ ___ \| | |__| ________ __ ____ \_ ___ \ ___________ ____ | | ______ ________ __ ___________
// / \ \/| | | |/ ____/ | \_/ __ \ / \ \/ / _ \_ __ \_/ __ \ | |/ ___// ___/ | \_/ __ \_ __ \
// \ \___| |_| < <_| | | /\ ___/ \ \___( <_> ) | \/\ ___/ | |\___ \ \___ \| | /\ ___/| | \/
// \______ /____/__|\__ |____/ \___ > \______ /\____/|__| \___ > |___/____ >____ >____/ \___ >__|
// \/ |__| \/ \/ \/ \/ \/ \/
contract CoreIssuerV3 is AccessControl, Pausable {
using ECDSA for bytes32;
AccountBoundToken public ABT;
bytes32 public constant PROJECT_ROLE = keccak256("PROJECT_ROLE");
uint256 public _tokenId; // available tokenId.
address public _relayer;
address public _withdrawAddress;
mapping(string id => Project project) public _projects;
/// @notice Emitted in the batchAirdrop when a credentail cannot be issued due to invalid-data
/// @dev This event allows the function to succeed and infrom on failed credential issuances.
/// @param receiver The receiver of the SBT.
/// @param id The id of the Project.
/// @param credentialURL The credentialURL of the SBT.
/// @param proof The merkle proof that the credential-data is in the merkle-tree.
event InvalidData(
address receiver,
string id,
string credentialURL,
bytes32[] proof
);
event ProjectSet(
address projectOwner,
uint256 tokenId,
string id,
bytes32 root,
uint256 fee
);
event ProjectUpdate(
string id,
bytes32 root,
uint256 fee
);
/// @notice Modifier to check if the fee is sufficient.
/// @param id The id of the project.
modifier feeCheck(string calldata id) {
if (msg.value < _projects[id].fee) revert InsufficientFee();
_;
}
/// @notice Restricts function callers to the Relayer.
modifier onlyRelayer() {
require(msg.sender == _relayer, "Signer must be the Relayer");
_;
}
/// @notice Constructor sets the SBT address, id, and Access Roles.
/// @param _ABT The address of the SBT.
/// @param tokenId The tokenId of the first set of SBTs to be issued.
constructor(address _ABT, address relayer, address withdrawAddress, uint256 tokenId) {
ABT = AccountBoundToken(_ABT);
_relayer = relayer;
_tokenId = tokenId;
_withdrawAddress = withdrawAddress;
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
_setupRole(PROJECT_ROLE, msg.sender);
}
/// @notice Sets the withdraw address.
/// @param withdrawAddress The address of the withdraw address.
function setWithdrawAddress(address withdrawAddress) external onlyRole(DEFAULT_ADMIN_ROLE) {
_withdrawAddress = withdrawAddress;
}
/// @notice Withdraws the contract balance to the withdraw address.
function withdraw() external onlyRole(DEFAULT_ADMIN_ROLE) {
if (_withdrawAddress == address(0)) revert WithdrawAddressNotSet();
payable(_withdrawAddress).transfer(address(this).balance);
}
/// @notice User mint sbt credential token in the merkle-tree.
/// @param receiver The receiver of the SBT.
/// @param id The id of the Project.
/// @param credentialURL The credentialURL of the SBT.
/// @param proof The merkle proof that the credential-data is in the merkle-tree.
function mintCredential(
address receiver,
string calldata id,
string calldata credentialURL,
bytes32[] calldata proof
) external payable whenNotPaused feeCheck(id){
if (_projects[id].root == bytes32(0)) revert ProjectHasNoRoot(id);
if (!_verify(id, _leaf(receiver, credentialURL), proof))
revert InvalidMerkleProof(receiver, id, credentialURL, proof);
ABT.issue(receiver, _projects[id].tokenId, credentialURL);
}
/// @notice Relayer issues a SBT to the provided receiver address.
/// @param receiver The receiver of the SBT.
/// @param id The id of the Project.
/// @param credentialURL The credentialURL of the SBT.
/// @param proof The merkle proof that the credential-data is in the merkle-tree.
function issueCredential(
address receiver,
string calldata id,
string calldata credentialURL,
bytes32[] calldata proof
) external onlyRelayer {
if (_projects[id].root == bytes32(0)) revert ProjectHasNoRoot(id);
if (!_verify(id, _leaf(receiver, credentialURL), proof))
revert InvalidMerkleProof(receiver, id, credentialURL, proof);
ABT.issue(receiver, _projects[id].tokenId, credentialURL);
}
/// @notice Updates the credential URL of the provided receiver's SBT.
/// @param receiver The address to receive the Phaver SBT.
/// @param id The id of the Project.
/// @param credentialURL URL of the caller's updated credentials.
/// @param signature Message signed by the relayer off chain.
function updateCredential(
address receiver,
string calldata id,
string memory credentialURL,
bytes memory signature
) external payable whenNotPaused feeCheck(id) {
if (_projects[id].projectOwner == address(0)) revert ProjectNotExist();
uint256 tokenId = _projects[id].tokenId;
bool res = ABT.ownerOf(receiver, tokenId);
if (res != true) revert ReceiverNotOwner();
if (msg.sender != receiver) revert InvalidSigner(msg.sender, receiver);
bytes32 messageHash = keccak256(
abi.encode(receiver, id, credentialURL, address(this))
);
if (messageHash.toEthSignedMessageHash().recover(signature) != _relayer)
revert InvalidSignature();
ABT.update(receiver, tokenId, credentialURL);
}
/// @notice Sets a new project with a specific id, merkle root, fee.
/// @param id The id for this project.
/// @param root The root of the merkle tree.
/// @param fee The payment to claim SBT.
function setProject(
string calldata id,
bytes32 root,
uint256 fee
) external whenNotPaused {
address projectOwner = msg.sender;
if (_projects[id].projectOwner != address(0)) revert ProjectAlreadyExist();
_projects[id] = Project(
projectOwner,
_tokenId,
id,
root,
fee
);
emit ProjectSet(
projectOwner,
_tokenId,
id,
root,
fee
);
++_tokenId;
}
/// @notice Update existed project with a specific id, merkle root, fee.
/// @param id The id for this project.
/// @param root The root of the merkle tree.
/// @param fee The payment to claim SBT.
function updateProject(
string calldata id,
bytes32 root,
uint256 fee
) external whenNotPaused {
address projectOwner = msg.sender;
if (_projects[id].projectOwner != projectOwner) revert CallerNotProjectOwner();
_projects[id].root = root;
_projects[id].fee = fee;
emit ProjectUpdate(
id,
root,
fee
);
}
/// @notice Aidrops SBTs to a list of receivers in the merkle-tree.
/// @param leaves The list of credential-data to be issued.
function airdropCredentials(
SBTAirdropData[] calldata leaves
) external onlyRole(PROJECT_ROLE) whenNotPaused {
for (uint256 i = 0; i < leaves.length; ++i) {
if (_projects[leaves[i].id].root == bytes32(0))
revert ProjectHasNoRoot(leaves[i].id);
string calldata id = leaves[i].id;
address receiver = leaves[i].receiver;
string calldata credentialURL = leaves[i].credentialURL;
bytes32[] calldata proof = leaves[i].proof;
if (!_verify(id, _leaf(receiver, credentialURL), proof)) {
emit InvalidData(receiver, id, credentialURL, proof);
continue; // If the data is invalid, skip to the next loop iteration.
}
ABT.issue(receiver, _projects[id].tokenId, credentialURL);
}
}
/// @notice Returns the ABT address.
function getABT() public view returns (address) {
return address(ABT);
}
// The owner can call this function to pause functions with "whenNotPaused" modifier.
function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
_pause();
}
// The owner can call this function to unpause functions with "whenNotPaused" modifier.
function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
_unpause();
}
/// @notice Sets the relayer address.
/// @param relayer The address of the relayer.
function setRelayer(address relayer) external onlyRole(DEFAULT_ADMIN_ROLE) {
_relayer = relayer;
}
/// @notice Constructs a merkle-tree leaf.
/// @param receiver The receiver of the SBT.
/// @param credentialURL The credentialURL of the SBT.
function _leaf(
address receiver,
string calldata credentialURL
) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(receiver, credentialURL));
}
/// @notice Verifies a given leaf is in the merkle-tree with the given root.
function _verify(
string calldata id,
bytes32 leaf,
bytes32[] calldata proof
) internal view returns (bool) {
bytes32 root = _projects[id].root;
return MerkleProofLib.verify(proof, root, leaf);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import "@openzeppelin/contracts-upgradeable/token/ERC1155/ERC1155Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import {IAccountBoundToken} from "../interfaces/IAccountBoundToken.sol";
/// @title AccountBoundToken
/// @author Clique
/// @custom:coauthor Ollie (eillo.eth)
/// @custom:coauthor Depetrol
contract AccountBoundToken is
IAccountBoundToken,
Initializable,
ERC1155Upgradeable,
AccessControlUpgradeable
{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ROLE CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
bytes32 public constant ISSUER_ROLE = keccak256("ISSUER_ROLE");
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STORAGE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
mapping(address => mapping(uint256 => string)) public _credentialURL; // account => id => credentialURL
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* MODIFIERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Restricts function callers to ABT holder or admin.
/// @param account The account of the function caller.
/// @param id The id of the ABT.
modifier onlyHolderOrOwner(address account, uint256 id) {
// function caller must be the account and an ABT owner, or admin.
if (
(msg.sender != account || ownerOf(msg.sender, id) == false) &&
hasRole(DEFAULT_ADMIN_ROLE, msg.sender) == false
) {
revert AccessRestricted(msg.sender);
}
_;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTRUCTOR & INITIALIZER */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
_disableInitializers();
}
/// @dev Initialize function, to be called by the proxy delegating calls to this implementation.
/// @notice Initializes the ABT, AccessControl and sets the roles to the deployer.
function initialize() public initializer {
__ERC1155_init("");
__AccessControl_init();
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
_grantRole(ISSUER_ROLE, msg.sender);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EXTERNAL FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Sets the URI, following ERC1155 standard.
/// @param uri The URI to be set.
function setURI(string memory uri) external onlyRole(DEFAULT_ADMIN_ROLE) {
_setURI(uri);
}
/// @inheritdoc IAccountBoundToken
function issue(
address account,
uint256 id,
string memory credentialURL
) external override onlyRole(ISSUER_ROLE) {
if (ownerOf(account, id)) revert AlreadyIssued(account, id);
_credentialURL[account][id] = credentialURL;
_mint(account, id, 1, "");
emit UpdateCredential(account, id, credentialURL);
}
/// @inheritdoc IAccountBoundToken
function update(
address account,
uint256 id,
string memory credentialURL
) external override onlyRole(ISSUER_ROLE) {
if (_isRevoked(account, id)) revert Revoked(account, id);
_credentialURL[account][id] = credentialURL;
emit UpdateCredential(account, id, credentialURL);
}
/// @inheritdoc IAccountBoundToken
function burn(
address account,
uint256 id
) external override onlyHolderOrOwner(account, id) {
if (_isRevoked(account, id)) revert Revoked(account, id);
_credentialURL[account][id] = "Revoked";
_burn(account, id, 1);
emit UpdateCredential(account, id, _credentialURL[account][id]);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* PUBLIC FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IAccountBoundToken
function ownerOf(
address account,
uint256 tokenId
) public view override returns (bool) {
return balanceOf(account, tokenId) != 0;
}
// @notice ABT is non-transferable
function setApprovalForAll(
address operator,
bool approved
) public view virtual override {
revert AccountBound();
}
// @notice ABT is non-transferable
function isApprovedForAll(
address account,
address operator
) public view virtual override returns (bool) {
revert AccountBound();
}
/// @inheritdoc ERC1155Upgradeable
function supportsInterface(
bytes4 interfaceId
)
public
view
override(ERC1155Upgradeable, AccessControlUpgradeable)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INTERNAL FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice checks if an ABT with the given account and id is revoked.
/// @param account The account of the ABT owner.
/// @param id The id of the ABT.
function _isRevoked(
address account,
uint256 id
) internal view returns (bool) {
bytes32 credentialHash = keccak256(
abi.encode(_credentialURL[account][id])
);
bytes32 revokedHash = keccak256(abi.encode("Revoked"));
return credentialHash == revokedHash;
}
// @notice ABT is non-transferable
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
if (!(from == address(0) || to == address(0))) revert AccountBound();
}
/// @notice Emits Attest event when a token is minted and Revoke when it
/// is burned.
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
if (from == address(0)) {
emit Attest(to, ids[0]);
}
if (to == address(0)) {
emit Revoke(address(0), ids[0]);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.0;
import "../Strings.sol";
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV // Deprecated in v4.8
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature` or error string. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*
* _Available since v4.3._
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*
* _Available since v4.2._
*/
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*
* _Available since v4.3._
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
/**
* @dev Returns an Ethereum Signed Message, created from a `hash`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
/**
* @dev Returns an Ethereum Signed Message, created from `s`. This
* produces hash corresponding to the one signed with the
* https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
* JSON-RPC method as part of EIP-191.
*
* See {recover}.
*/
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
/**
* @dev Returns an Ethereum Signed Typed Data, created from a
* `domainSeparator` and a `structHash`. This produces hash corresponding
* to the one signed with the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
* JSON-RPC method as part of EIP-712.
*
* See {recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor() {
_paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
return _paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)
pragma solidity ^0.8.0;
import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `_msgSender()` is missing `role`.
* Overriding this function changes the behavior of the {onlyRole} modifier.
*
* Format of the revert message is described in {_checkRole}.
*
* _Available since v4.6._
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(account),
" is missing role ",
Strings.toHexString(uint256(role), 32)
)
)
);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleGranted} event.
*/
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleRevoked} event.
*/
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been revoked `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* May emit a {RoleGranted} event.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*
* NOTE: This function is deprecated in favor of {_grantRole}.
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Grants `role` to `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
/**
* @dev Revokes `role` from `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
/// @notice Gas optimized merkle proof verification library.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/MerkleProofLib.sol)
library MerkleProofLib {
function verify(
bytes32[] calldata proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool isValid) {
assembly {
if proof.length {
// Left shifting by 5 is like multiplying by 32.
let end := add(proof.offset, shl(5, proof.length))
// Initialize offset to the offset of the proof in calldata.
let offset := proof.offset
// Iterate over proof elements to compute root hash.
// prettier-ignore
for {} 1 {} {
// Slot where the leaf should be put in scratch space. If
// leaf > calldataload(offset): slot 32, otherwise: slot 0.
let leafSlot := shl(5, gt(leaf, calldataload(offset)))
// Store elements to hash contiguously in scratch space.
// The xor puts calldataload(offset) in whichever slot leaf
// is not occupying, so 0 if leafSlot is 32, and 32 otherwise.
mstore(leafSlot, leaf)
mstore(xor(leafSlot, 32), calldataload(offset))
// Reuse leaf to store the hash to reduce stack operations.
leaf := keccak256(0, 64) // Hash both slots of scratch space.
offset := add(offset, 32) // Shift 1 word per cycle.
// prettier-ignore
if iszero(lt(offset, end)) { break }
}
}
isValid := eq(leaf, root) // The proof is valid if the roots match.
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
/// @title IAccountBoundToken
/// @author Clique
/// @custom:coauthor Ollie (eillo.eth)
/// @custom:coauthor Depetrol
interface IAccountBoundToken {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error AccountBound();
error Revoked(address account, uint256 id);
error AlreadyIssued(address account, uint256 id);
error AccessRestricted(address account);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev This emits when a new token is created and bound to an account by
/// any mechanism.
event Attest(address indexed to, uint256 indexed tokenId);
/// @dev This emits when an existing ABT is revoked from an account and
/// burnt.
event Revoke(address indexed to, uint256 indexed tokenId);
/// @dev This emits when updating the credential URL of an ABT.
/// @param account The account that owns the ABT.
/// @param id The ID of the ABT.
/// @param credentialURL The new credential URL.
event UpdateCredential(
address indexed account,
uint256 indexed id,
string credentialURL
);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EXTERNAL FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Issues an ABT with the given id to the given account.
/// @param account The account to issue the ABT to.
/// @param id The id of the ABT being issued.
/// @param credentialURL The URL of the credential that the ABT is bound to.
function issue(
address account,
uint256 id,
string memory credentialURL
) external;
/// @notice Updates the credential URL of an ABT.
/// @param account The account that owns the ABT.
/// @param id The id of the ABT to be updated.
/// @param credentialURL The new credential URL.
function update(
address account,
uint256 id,
string memory credentialURL
) external;
/// @notice Burns token with given id. At any time, an ABT
/// receiver must be able to disassociate themselves from an ABT
/// publicly through calling this function.
/// @dev Must emit a `event Revoke` with the `address to` field pointing to
/// the zero address.
/// @param account The address of the owner of the ABT.
/// @param id The identifier for an ABT
function burn(address account, uint256 id) external;
/// @notice Checks if an account is an owner of a token.
/// @param account The address of the owner
/// @param tokenId The identifier for an ABT
/// @return The address of the owner bound to the ABT
function ownerOf(address account, uint256 tokenId)
external
view
returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
import "./IERC1155Upgradeable.sol";
import "./IERC1155ReceiverUpgradeable.sol";
import "./extensions/IERC1155MetadataURIUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155Upgradeable, IERC1155MetadataURIUpgradeable {
using AddressUpgradeable for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
function __ERC1155_init(string memory uri_) internal onlyInitializing {
__ERC1155_init_unchained(uri_);
}
function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing {
_setURI(uri_);
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC1155Upgradeable).interfaceId ||
interfaceId == type(IERC1155MetadataURIUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the `\{id\}` substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
//
// ipfs://hash-common/dir/{id}.json
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `ids` and `amounts` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
/**
* @dev Hook that is called after any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155ReceiverUpgradeable.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155ReceiverUpgradeable.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[47] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/AccessControl.sol)
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `_msgSender()` is missing `role`.
* Overriding this function changes the behavior of the {onlyRole} modifier.
*
* Format of the revert message is described in {_checkRole}.
*
* _Available since v4.6._
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
StringsUpgradeable.toHexString(uint160(account), 20),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32)
)
)
);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleGranted} event.
*/
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleRevoked} event.
*/
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been revoked `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* May emit a {RoleGranted} event.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*
* NOTE: This function is deprecated in favor of {_grantRole}.
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Grants `role` to `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
/**
* @dev Revokes `role` from `account`.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
* initialization step. This is essential to configure modules that are added through upgrades and that require
* initialization.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
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");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
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");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/
interface IERC1155Upgradeable is IERC165Upgradeable {
/**
* @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
* transfers.
*/
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
/**
* @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
* `approved`.
*/
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
/**
* @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
*
* If an {URI} event was emitted for `id`, the standard
* https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
* returned by {IERC1155MetadataURI-uri}.
*/
event URI(string value, uint256 indexed id);
/**
* @dev Returns the amount of tokens of token type `id` owned by `account`.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) external view returns (uint256);
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
/**
* @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
*
* Emits an {ApprovalForAll} event.
*
* Requirements:
*
* - `operator` cannot be the caller.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address account, address operator) external view returns (bool);
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `amount`.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev _Available since v3.1._
*/
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
/**
* @dev Handles the receipt of a single ERC1155 token type. This function is
* called at the end of a `safeTransferFrom` after the balance has been updated.
*
* NOTE: To accept the transfer, this must return
* `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
* (i.e. 0xf23a6e61, or its own function selector).
*
* @param operator The address which initiated the transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param id The ID of the token being transferred
* @param value The amount of tokens being transferred
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
/**
* @dev Handles the receipt of a multiple ERC1155 token types. This function
* is called at the end of a `safeBatchTransferFrom` after the balances have
* been updated.
*
* NOTE: To accept the transfer(s), this must return
* `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
* (i.e. 0xbc197c81, or its own function selector).
*
* @param operator The address which initiated the batch transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param ids An array containing ids of each token being transferred (order and length must match values array)
* @param values An array containing amounts of each token being transferred (order and length must match ids array)
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)
pragma solidity ^0.8.0;
import "../IERC1155Upgradeable.sol";
/**
* @dev Interface of the optional ERC1155MetadataExtension interface, as defined
* in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
*
* _Available since v3.1._
*/
interface IERC1155MetadataURIUpgradeable is IERC1155Upgradeable {
/**
* @dev Returns the URI for token type `id`.
*
* If the `\{id\}` substring is present in the URI, it must be replaced by
* clients with the actual token type ID.
*/
function uri(uint256 id) external view returns (string memory);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165Upgradeable {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
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);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
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] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControlUpgradeable {
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/Math.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
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);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
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;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
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);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
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);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 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;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
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);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 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;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
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);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
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;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
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);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControl {
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*
* _Available since v3.1._
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `account`.
*/
function renounceRole(bytes32 role, address account) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}{
"optimizer": {
"enabled": true,
"runs": 1000
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"libraries": {}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"address","name":"_ABT","type":"address"},{"internalType":"address","name":"relayer","type":"address"},{"internalType":"address","name":"withdrawAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CallerNotProjectOwner","type":"error"},{"inputs":[],"name":"InsufficientFee","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string","name":"id","type":"string"},{"internalType":"string","name":"credentialURL","type":"string"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"InvalidMerkleProof","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"},{"internalType":"address","name":"receiver","type":"address"}],"name":"InvalidSigner","type":"error"},{"inputs":[],"name":"ProjectAlreadyExist","type":"error"},{"inputs":[{"internalType":"string","name":"id","type":"string"}],"name":"ProjectHasNoRoot","type":"error"},{"inputs":[],"name":"ProjectNotExist","type":"error"},{"inputs":[],"name":"ReceiverNotOwner","type":"error"},{"inputs":[],"name":"WithdrawAddressNotSet","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"string","name":"id","type":"string"},{"indexed":false,"internalType":"string","name":"credentialURL","type":"string"},{"indexed":false,"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"InvalidData","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"projectOwner","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"string","name":"id","type":"string"},{"indexed":false,"internalType":"bytes32","name":"root","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"ProjectSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"id","type":"string"},{"indexed":false,"internalType":"bytes32","name":"root","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"ProjectUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"ABT","outputs":[{"internalType":"contract AccountBoundToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROJECT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"id","type":"string"}],"name":"_projects","outputs":[{"internalType":"address","name":"projectOwner","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"id","type":"string"},{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint256","name":"fee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_relayer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_tokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_withdrawAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string","name":"id","type":"string"},{"internalType":"string","name":"credentialURL","type":"string"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"internalType":"struct SBTAirdropData[]","name":"leaves","type":"tuple[]"}],"name":"airdropCredentials","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getABT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string","name":"id","type":"string"},{"internalType":"string","name":"credentialURL","type":"string"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"issueCredential","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string","name":"id","type":"string"},{"internalType":"string","name":"credentialURL","type":"string"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"mintCredential","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"id","type":"string"},{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint256","name":"fee","type":"uint256"}],"name":"setProject","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"relayer","type":"address"}],"name":"setRelayer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"withdrawAddress","type":"address"}],"name":"setWithdrawAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string","name":"id","type":"string"},{"internalType":"string","name":"credentialURL","type":"string"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"updateCredential","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"string","name":"id","type":"string"},{"internalType":"bytes32","name":"root","type":"bytes32"},{"internalType":"uint256","name":"fee","type":"uint256"}],"name":"updateProject","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
0x6080604052600436106101a15760003560e01c806361b8c43f116100e15780639fe6678c1161008a578063d547741f11610064578063d547741f146104a8578063e64d1983146104c8578063fc262812146104e8578063fd07bf181461050857600080fd5b80639fe6678c1461042e578063a217fddf14610462578063cba7bf5e1461047757600080fd5b80638456cb59116100bb5780638456cb59146103b557806391d14854146103ca578063940e50f61461040e57600080fd5b806361b8c43f1461036f57806364d76679146103825780636548e9bc1461039557600080fd5b806336568abe1161014e5780633f4ba83a116101285780633f4ba83a146102e6578063444647d7146102fb57806348f7a65b146103325780635c975abb1461035757600080fd5b806336568abe146102915780633ab1a494146102b15780633ccfd60b146102d157600080fd5b8063248225141161017f578063248225141461021d578063248a9ca3146102415780632f2ff15d1461027157600080fd5b806301ffc9a7146101a657806302395665146101db5780632205b1a4146101fd575b600080fd5b3480156101b257600080fd5b506101c66101c1366004611c93565b610528565b60405190151581526020015b60405180910390f35b3480156101e757600080fd5b506101fb6101f6366004611d02565b610591565b005b34801561020957600080fd5b506101fb610218366004611d86565b610884565b34801561022957600080fd5b5061023360025481565b6040519081526020016101d2565b34801561024d57600080fd5b5061023361025c366004611dd7565b60009081526020819052604090206001015490565b34801561027d57600080fd5b506101fb61028c366004611e0c565b610987565b34801561029d57600080fd5b506101fb6102ac366004611e0c565b6109b1565b3480156102bd57600080fd5b506101fb6102cc366004611e38565b610a3d565b3480156102dd57600080fd5b506101fb610a78565b3480156102f257600080fd5b506101fb610afe565b34801561030757600080fd5b5060015461010090046001600160a01b03165b6040516001600160a01b0390911681526020016101d2565b34801561033e57600080fd5b5060015461031a9061010090046001600160a01b031681565b34801561036357600080fd5b5060015460ff166101c6565b6101fb61037d366004611eff565b610b14565b6101fb610390366004611fb2565b610e91565b3480156103a157600080fd5b506101fb6103b0366004611e38565b611011565b3480156103c157600080fd5b506101fb61104c565b3480156103d657600080fd5b506101c66103e5366004611e0c565b6000918252602082815260408084206001600160a01b0393909316845291905290205460ff1690565b34801561041a57600080fd5b5060035461031a906001600160a01b031681565b34801561043a57600080fd5b506102337f99b4cb81d693045578a6795d2045a8e4a6dc2d789bd539397ae2ce05c660459981565b34801561046e57600080fd5b50610233600081565b34801561048357600080fd5b5061049761049236600461205d565b61105f565b6040516101d29594939291906120ea565b3480156104b457600080fd5b506101fb6104c3366004611e0c565b61112b565b3480156104d457600080fd5b506101fb6104e3366004611fb2565b611150565b3480156104f457600080fd5b506101fb610503366004611d86565b6112d4565b34801561051457600080fd5b5060045461031a906001600160a01b031681565b60006001600160e01b031982167f7965db0b00000000000000000000000000000000000000000000000000000000148061058b57507f01ffc9a7000000000000000000000000000000000000000000000000000000006001600160e01b03198316145b92915050565b7f99b4cb81d693045578a6795d2045a8e4a6dc2d789bd539397ae2ce05c66045996105bb81611489565b6105c3611493565b60005b8281101561087e57600060058585848181106105e4576105e4612126565b90506020028101906105f6919061213c565b61060490602081019061215c565b6040516106129291906121a3565b9081526020016040518091039020600301540361067f5783838281811061063b5761063b612126565b905060200281019061064d919061213c565b61065b90602081019061215c565b6040516303431deb60e01b81526004016106769291906121dc565b60405180910390fd5b36600085858481811061069457610694612126565b90506020028101906106a6919061213c565b6106b490602081019061215c565b9150915060008686858181106106cc576106cc612126565b90506020028101906106de919061213c565b6106ec906020810190611e38565b905036600088888781811061070357610703612126565b9050602002810190610715919061213c565b61072390604081019061215c565b915091503660008a8a8981811061073c5761073c612126565b905060200281019061074e919061213c565b61075c9060608101906121f0565b9150915061077787876107708888886114e8565b858561151e565b6107ca577fd5b5a0776b5d646c6c2b5d218ee0aff4855a07b6f373a5d580ccd8093d285993858888878787876040516107b6979695949392919061223a565b60405180910390a15050505050505061086e565b60018054906101000a90046001600160a01b03166001600160a01b031663ebf469dc8660058a8a6040516107ff9291906121a3565b908152604051908190036020018120600101546001600160e01b031960e085901b1682526108349291899089906004016122c6565b600060405180830381600087803b15801561084e57600080fd5b505af1158015610862573d6000803e3d6000fd5b50505050505050505050505b6108778161230f565b90506105c6565b50505050565b61088c611493565b604051339081906005906108a390889088906121a3565b908152604051908190036020019020546001600160a01b0316146108f3576040517f0a87933e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b82600586866040516109069291906121a3565b908152602001604051809103902060030181905550816005868660405161092e9291906121a3565b9081526020016040518091039020600401819055507f411bc059f61ae69562028d01cc0dc6de97b14ea7155c052ab9d549d9d8b4f591858585856040516109789493929190612328565b60405180910390a15050505050565b6000828152602081905260409020600101546109a281611489565b6109ac838361155e565b505050565b6001600160a01b0381163314610a2f5760405162461bcd60e51b815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201527f20726f6c657320666f722073656c6600000000000000000000000000000000006064820152608401610676565b610a3982826115fc565b5050565b6000610a4881611489565b506004805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0392909216919091179055565b6000610a8381611489565b6004546001600160a01b0316610ac5576040517fa68b8f8700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6004546040516001600160a01b03909116904780156108fc02916000818181858888f19350505050158015610a39573d6000803e3d6000fd5b6000610b0981611489565b610b1161167b565b50565b610b1c611493565b838360058282604051610b309291906121a3565b908152602001604051809103902060040154341015610b615760405162976f7560e21b815260040160405180910390fd5b60006001600160a01b031660058787604051610b7e9291906121a3565b908152604051908190036020019020546001600160a01b031603610bce576040517f94fea47c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060058787604051610be29291906121a3565b90815260405190819003602001812060019081015490547f1f29d2dc0000000000000000000000000000000000000000000000000000000083526001600160a01b038b81166004850152602484018390529193506000926101009091049190911690631f29d2dc90604401602060405180830381865afa158015610c6a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c8e919061234f565b9050600181151514610ccc576040517fb25acf3700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b336001600160a01b038a1614610d1f576040517f7ba5ffb50000000000000000000000000000000000000000000000000000000081523360048201526001600160a01b038a166024820152604401610676565b60008989898930604051602001610d3a959493929190612371565b60408051601f1981840301815291905280516020909101206003549091506001600160a01b0316610dc287610dbc846040517f19457468657265756d205369676e6564204d6573736167653a0a3332000000006020820152603c8101829052600090605c01604051602081830303815290604052805190602001209050919050565b906116cd565b6001600160a01b031614610e02576040517f8baa579f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001546040517fed3bfdea0000000000000000000000000000000000000000000000000000000081526101009091046001600160a01b03169063ed3bfdea90610e53908d9087908c906004016123bd565b600060405180830381600087803b158015610e6d57600080fd5b505af1158015610e81573d6000803e3d6000fd5b5050505050505050505050505050565b610e99611493565b858560058282604051610ead9291906121a3565b908152602001604051809103902060040154341015610ede5760405162976f7560e21b815260040160405180910390fd5b6000801b60058989604051610ef49291906121a3565b90815260200160405180910390206003015403610f285787876040516303431deb60e01b81526004016106769291906121dc565b610f3f8888610f388c8a8a6114e8565b878761151e565b610f6a57888888888888886040516305c7a02960e51b8152600401610676979695949392919061223a565b60018054906101000a90046001600160a01b03166001600160a01b031663ebf469dc8a60058b8b604051610f9f9291906121a3565b908152604051908190036020018120600101546001600160e01b031960e085901b168252610fd492918b908b906004016122c6565b600060405180830381600087803b158015610fee57600080fd5b505af1158015611002573d6000803e3d6000fd5b50505050505050505050505050565b600061101c81611489565b506003805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0392909216919091179055565b600061105781611489565b610b116116f1565b80516020818301810180516005825292820191909301209152805460018201546002830180546001600160a01b0390931693919261109c906123ee565b80601f01602080910402602001604051908101604052809291908181526020018280546110c8906123ee565b80156111155780601f106110ea57610100808354040283529160200191611115565b820191906000526020600020905b8154815290600101906020018083116110f857829003601f168201915b5050505050908060030154908060040154905085565b60008281526020819052604090206001015461114681611489565b6109ac83836115fc565b6003546001600160a01b031633146111aa5760405162461bcd60e51b815260206004820152601a60248201527f5369676e6572206d757374206265207468652052656c617965720000000000006044820152606401610676565b6000801b600587876040516111c09291906121a3565b908152602001604051809103902060030154036111f45785856040516303431deb60e01b81526004016106769291906121dc565b61120486866107708a88886114e8565b61122f57868686868686866040516305c7a02960e51b8152600401610676979695949392919061223a565b60018054906101000a90046001600160a01b03166001600160a01b031663ebf469dc88600589896040516112649291906121a3565b908152604051908190036020018120600101546001600160e01b031960e085901b1682526112999291899089906004016122c6565b600060405180830381600087803b1580156112b357600080fd5b505af11580156112c7573d6000803e3d6000fd5b5050505050505050505050565b6112dc611493565b60405133906000906005906112f490889088906121a3565b908152604051908190036020019020546001600160a01b031614611344576040517f843e305a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040518060a00160405280826001600160a01b03168152602001600254815260200186868080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250505090825250602081018590526040908101849052516005906113bf90889088906121a3565b90815260408051602092819003830190208351815473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0390911617815591830151600183015582015160028201906114149082612476565b5060608201518160030155608082015181600401559050507f89d6776edfcfafafa5c69da9212945ea481560b4cf4a57ae36450a6318eb2636816002548787878760405161146796959493929190612536565b60405180910390a160026000815461147e9061230f565b909155505050505050565b610b11813361172c565b60015460ff16156114e65760405162461bcd60e51b815260206004820152601060248201527f5061757361626c653a20706175736564000000000000000000000000000000006044820152606401610676565b565b60008383836040516020016114ff93929190612574565b6040516020818303038152906040528051906020012090509392505050565b600080600587876040516115339291906121a3565b90815260200160405180910390206003015490506115538484838861179f565b979650505050505050565b6000828152602081815260408083206001600160a01b038516845290915290205460ff16610a39576000828152602081815260408083206001600160a01b03851684529091529020805460ff191660011790556115b83390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b6000828152602081815260408083206001600160a01b038516845290915290205460ff1615610a39576000828152602081815260408083206001600160a01b0385168085529252808320805460ff1916905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b6116836117d9565b6001805460ff191690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b6040516001600160a01b03909116815260200160405180910390a1565b60008060006116dc858561182b565b915091506116e981611870565b509392505050565b6116f9611493565b6001805460ff1916811790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258336116b0565b6000828152602081815260408083206001600160a01b038516845290915290205460ff16610a395761175d816119d5565b6117688360206119e7565b6040516020016117799291906125a0565b60408051601f198184030181529082905262461bcd60e51b825261067691600401612621565b600083156117d1578360051b8501855b803580851160051b948552602094851852604060002093018181106117af5750505b501492915050565b60015460ff166114e65760405162461bcd60e51b815260206004820152601460248201527f5061757361626c653a206e6f74207061757365640000000000000000000000006044820152606401610676565b60008082516041036118615760208301516040840151606085015160001a61185587828585611bcf565b94509450505050611869565b506000905060025b9250929050565b600081600481111561188457611884612634565b0361188c5750565b60018160048111156118a0576118a0612634565b036118ed5760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610676565b600281600481111561190157611901612634565b0361194e5760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610676565b600381600481111561196257611962612634565b03610b115760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c60448201527f75650000000000000000000000000000000000000000000000000000000000006064820152608401610676565b606061058b6001600160a01b03831660145b606060006119f683600261264a565b611a01906002612661565b67ffffffffffffffff811115611a1957611a19611e53565b6040519080825280601f01601f191660200182016040528015611a43576020820181803683370190505b5090507f300000000000000000000000000000000000000000000000000000000000000081600081518110611a7a57611a7a612126565b60200101906001600160f81b031916908160001a9053507f780000000000000000000000000000000000000000000000000000000000000081600181518110611ac557611ac5612126565b60200101906001600160f81b031916908160001a9053506000611ae984600261264a565b611af4906001612661565b90505b6001811115611b79577f303132333435363738396162636465660000000000000000000000000000000085600f1660108110611b3557611b35612126565b1a60f81b828281518110611b4b57611b4b612126565b60200101906001600160f81b031916908160001a90535060049490941c93611b7281612674565b9050611af7565b508315611bc85760405162461bcd60e51b815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e746044820152606401610676565b9392505050565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115611c065750600090506003611c8a565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015611c5a573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b038116611c8357600060019250925050611c8a565b9150600090505b94509492505050565b600060208284031215611ca557600080fd5b81356001600160e01b031981168114611bc857600080fd5b60008083601f840112611ccf57600080fd5b50813567ffffffffffffffff811115611ce757600080fd5b6020830191508360208260051b850101111561186957600080fd5b60008060208385031215611d1557600080fd5b823567ffffffffffffffff811115611d2c57600080fd5b611d3885828601611cbd565b90969095509350505050565b60008083601f840112611d5657600080fd5b50813567ffffffffffffffff811115611d6e57600080fd5b60208301915083602082850101111561186957600080fd5b60008060008060608587031215611d9c57600080fd5b843567ffffffffffffffff811115611db357600080fd5b611dbf87828801611d44565b90989097506020870135966040013595509350505050565b600060208284031215611de957600080fd5b5035919050565b80356001600160a01b0381168114611e0757600080fd5b919050565b60008060408385031215611e1f57600080fd5b82359150611e2f60208401611df0565b90509250929050565b600060208284031215611e4a57600080fd5b611bc882611df0565b634e487b7160e01b600052604160045260246000fd5b600067ffffffffffffffff80841115611e8457611e84611e53565b604051601f8501601f19908116603f01168101908282118183101715611eac57611eac611e53565b81604052809350858152868686011115611ec557600080fd5b858560208301376000602087830101525050509392505050565b600082601f830112611ef057600080fd5b611bc883833560208501611e69565b600080600080600060808688031215611f1757600080fd5b611f2086611df0565b9450602086013567ffffffffffffffff80821115611f3d57600080fd5b611f4989838a01611d44565b90965094506040880135915080821115611f6257600080fd5b611f6e89838a01611edf565b93506060880135915080821115611f8457600080fd5b508601601f81018813611f9657600080fd5b611fa588823560208401611e69565b9150509295509295909350565b60008060008060008060006080888a031215611fcd57600080fd5b611fd688611df0565b9650602088013567ffffffffffffffff80821115611ff357600080fd5b611fff8b838c01611d44565b909850965060408a013591508082111561201857600080fd5b6120248b838c01611d44565b909650945060608a013591508082111561203d57600080fd5b5061204a8a828b01611cbd565b989b979a50959850939692959293505050565b60006020828403121561206f57600080fd5b813567ffffffffffffffff81111561208657600080fd5b61209284828501611edf565b949350505050565b60005b838110156120b557818101518382015260200161209d565b50506000910152565b600081518084526120d681602086016020860161209a565b601f01601f19169290920160200192915050565b6001600160a01b038616815284602082015260a06040820152600061211260a08301866120be565b606083019490945250608001529392505050565b634e487b7160e01b600052603260045260246000fd5b60008235607e1983360301811261215257600080fd5b9190910192915050565b6000808335601e1984360301811261217357600080fd5b83018035915067ffffffffffffffff82111561218e57600080fd5b60200191503681900382131561186957600080fd5b8183823760009101908152919050565b81835281816020850137506000828201602090810191909152601f909101601f19169091010190565b6020815260006120926020830184866121b3565b6000808335601e1984360301811261220757600080fd5b83018035915067ffffffffffffffff82111561222257600080fd5b6020019150600581901b360382131561186957600080fd5b6001600160a01b038816815260806020820152600061225d60808301888a6121b3565b82810360408401526122708187896121b3565b905082810360608401528381527f07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8411156122aa57600080fd5b8360051b80866020840137016020019998505050505050505050565b6001600160a01b03851681528360208201526060604082015260006122ef6060830184866121b3565b9695505050505050565b634e487b7160e01b600052601160045260246000fd5b600060018201612321576123216122f9565b5060010190565b60608152600061233c6060830186886121b3565b6020830194909452506040015292915050565b60006020828403121561236157600080fd5b81518015158114611bc857600080fd5b60006001600160a01b038088168352608060208401526123956080840187896121b3565b83810360408501526123a781876120be565b9250508084166060840152509695505050505050565b6001600160a01b03841681528260208201526060604082015260006123e560608301846120be565b95945050505050565b600181811c9082168061240257607f821691505b60208210810361242257634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156109ac57600081815260208120601f850160051c8101602086101561244f5750805b601f850160051c820191505b8181101561246e5782815560010161245b565b505050505050565b815167ffffffffffffffff81111561249057612490611e53565b6124a48161249e84546123ee565b84612428565b602080601f8311600181146124d957600084156124c15750858301515b600019600386901b1c1916600185901b17855561246e565b600085815260208120601f198616915b82811015612508578886015182559484019460019091019084016124e9565b50858210156125265787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b6001600160a01b038716815285602082015260a06040820152600061255f60a0830186886121b3565b60608301949094525060800152949350505050565b6bffffffffffffffffffffffff198460601b168152818360148301376000910160140190815292915050565b7f416363657373436f6e74726f6c3a206163636f756e74200000000000000000008152600083516125d881601785016020880161209a565b7f206973206d697373696e6720726f6c6520000000000000000000000000000000601791840191820152835161261581602884016020880161209a565b01602801949350505050565b602081526000611bc860208301846120be565b634e487b7160e01b600052602160045260246000fd5b808202811582820484141761058b5761058b6122f9565b8082018082111561058b5761058b6122f9565b600081612683576126836122f9565b50600019019056fea26469706673582212201d9ffb214ba1e1dd0186f3ad9ac6dac341961359efd702a1d86f3d556afdc46b64736f6c63430008130033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000017c1927aaae7a0ebecb6ff9bee83e15fdcae99c200000000000000000000000035a7e083ecfef16fd894fd9d4f9be0f644e9a67500000000000000000000000035a7e083ecfef16fd894fd9d4f9be0f644e9a6750000000000000000000000000000000000000000000000000000000000002710
-----Decoded View---------------
Arg [0] : _ABT (address): 0x17c1927aAAe7a0EbecB6Ff9BeE83E15FdCaE99c2
Arg [1] : relayer (address): 0x35a7e083eCfEF16fd894fD9d4f9BE0F644e9A675
Arg [2] : withdrawAddress (address): 0x35a7e083eCfEF16fd894fD9d4f9BE0F644e9A675
Arg [3] : tokenId (uint256): 10000
-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000017c1927aaae7a0ebecb6ff9bee83e15fdcae99c2
Arg [1] : 00000000000000000000000035a7e083ecfef16fd894fd9d4f9be0f644e9a675
Arg [2] : 00000000000000000000000035a7e083ecfef16fd894fd9d4f9be0f644e9a675
Arg [3] : 0000000000000000000000000000000000000000000000000000000000002710
Loading...
Loading
Loading...
Loading
Loading...
Loading
0xA9585635324eA3E41765042441de584b8f9d607A
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.