1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8 uint8 dummy;9 string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13 function supportsInterface(bytes4 interfaceID) external view returns (bool) {14 require(false, stub_error);15 interfaceID;16 return true;17 }18}1920/// @dev inlined interface21contract ERC721TokenEvent {22 event TokenChanged(uint256 indexed tokenId);23}2425/// @title A contract that allows to set and delete token properties and change token property permissions.26/// @dev the ERC-165 identifier for this interface is 0xde0695c227contract TokenProperties is Dummy, ERC165, ERC721TokenEvent {28 // /// @notice Set permissions for token property.29 // /// @dev Throws error if `msg.sender` is not admin or owner of the collection.30 // /// @param key Property key.31 // /// @param isMutable Permission to mutate property.32 // /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.33 // /// @param tokenOwner Permission to mutate property by token owner if property is mutable.34 // /// @dev EVM selector for this function is: 0x222d97fa,35 // /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)36 // function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) public {37 // require(false, stub_error);38 // key;39 // isMutable;40 // collectionAdmin;41 // tokenOwner;42 // dummy = 0;43 // }4445 /// @notice Set permissions for token property.46 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.47 /// @param permissions Permissions for keys.48 /// @dev EVM selector for this function is: 0xbd92983a,49 /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])50 function setTokenPropertyPermissions(TokenPropertyPermission[] memory permissions) public {51 require(false, stub_error);52 permissions;53 dummy = 0;54 }5556 /// @notice Get permissions for token properties.57 /// @dev EVM selector for this function is: 0xf23d7790,58 /// or in textual repr: tokenPropertyPermissions()59 function tokenPropertyPermissions() public view returns (TokenPropertyPermission[] memory) {60 require(false, stub_error);61 dummy;62 return new TokenPropertyPermission[](0);63 }6465 // /// @notice Set token property value.66 // /// @dev Throws error if `msg.sender` has no permission to edit the property.67 // /// @param tokenId ID of the token.68 // /// @param key Property key.69 // /// @param value Property value.70 // /// @dev EVM selector for this function is: 0x1752d67b,71 // /// or in textual repr: setProperty(uint256,string,bytes)72 // function setProperty(uint256 tokenId, string memory key, bytes memory value) public {73 // require(false, stub_error);74 // tokenId;75 // key;76 // value;77 // dummy = 0;78 // }7980 /// @notice Set token properties value.81 /// @dev Throws error if `msg.sender` has no permission to edit the property.82 /// @param tokenId ID of the token.83 /// @param properties settable properties84 /// @dev EVM selector for this function is: 0x14ed3a6e,85 /// or in textual repr: setProperties(uint256,(string,bytes)[])86 function setProperties(uint256 tokenId, Property[] memory properties) public {87 require(false, stub_error);88 tokenId;89 properties;90 dummy = 0;91 }9293 // /// @notice Delete token property value.94 // /// @dev Throws error if `msg.sender` has no permission to edit the property.95 // /// @param tokenId ID of the token.96 // /// @param key Property key.97 // /// @dev EVM selector for this function is: 0x066111d1,98 // /// or in textual repr: deleteProperty(uint256,string)99 // function deleteProperty(uint256 tokenId, string memory key) public {100 // require(false, stub_error);101 // tokenId;102 // key;103 // dummy = 0;104 // }105106 /// @notice Delete token properties value.107 /// @dev Throws error if `msg.sender` has no permission to edit the property.108 /// @param tokenId ID of the token.109 /// @param keys Properties key.110 /// @dev EVM selector for this function is: 0xc472d371,111 /// or in textual repr: deleteProperties(uint256,string[])112 function deleteProperties(uint256 tokenId, string[] memory keys) public {113 require(false, stub_error);114 tokenId;115 keys;116 dummy = 0;117 }118119 /// @notice Get token property value.120 /// @dev Throws error if key not found121 /// @param tokenId ID of the token.122 /// @param key Property key.123 /// @return Property value bytes124 /// @dev EVM selector for this function is: 0x7228c327,125 /// or in textual repr: property(uint256,string)126 function property(uint256 tokenId, string memory key) public view returns (bytes memory) {127 require(false, stub_error);128 tokenId;129 key;130 dummy;131 return hex"";132 }133}134135/// Ethereum representation of collection [`PropertyKey`](up_data_structs::PropertyKey) and [`PropertyValue`](up_data_structs::PropertyValue).136struct Property {137 string key;138 bytes value;139}140141/// Ethereum representation of Token Property Permissions.142struct TokenPropertyPermission {143 /// Token property key.144 string key;145 /// Token property permissions.146 PropertyPermission[] permissions;147}148149/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) as an key and value.150struct PropertyPermission {151 /// TokenPermission field.152 TokenPermissionField code;153 /// TokenPermission value.154 bool value;155}156157/// Ethereum representation of TokenPermissions (see [`up_data_structs::PropertyPermission`]) fields as an enumeration.158enum TokenPermissionField {159 /// Permission to change the property and property permission. See [`up_data_structs::PropertyPermission::mutable`]160 Mutable,161 /// Change permission for the collection administrator. See [`up_data_structs::PropertyPermission::token_owner`]162 TokenOwner,163 /// Permission to change the property for the owner of the token. See [`up_data_structs::PropertyPermission::collection_admin`]164 CollectionAdmin165}166167/// @title A contract that allows you to work with collections.168/// @dev the ERC-165 identifier for this interface is 0x2a14cfd1169contract Collection is Dummy, ERC165 {170 // /// Set collection property.171 // ///172 // /// @param key Property key.173 // /// @param value Propery value.174 // /// @dev EVM selector for this function is: 0x2f073f66,175 // /// or in textual repr: setCollectionProperty(string,bytes)176 // function setCollectionProperty(string memory key, bytes memory value) public {177 // require(false, stub_error);178 // key;179 // value;180 // dummy = 0;181 // }182183 /// Set collection properties.184 ///185 /// @param properties Vector of properties key/value pair.186 /// @dev EVM selector for this function is: 0x50b26b2a,187 /// or in textual repr: setCollectionProperties((string,bytes)[])188 function setCollectionProperties(Property[] memory properties) public {189 require(false, stub_error);190 properties;191 dummy = 0;192 }193194 // /// Delete collection property.195 // ///196 // /// @param key Property key.197 // /// @dev EVM selector for this function is: 0x7b7debce,198 // /// or in textual repr: deleteCollectionProperty(string)199 // function deleteCollectionProperty(string memory key) public {200 // require(false, stub_error);201 // key;202 // dummy = 0;203 // }204205 /// Delete collection properties.206 ///207 /// @param keys Properties keys.208 /// @dev EVM selector for this function is: 0xee206ee3,209 /// or in textual repr: deleteCollectionProperties(string[])210 function deleteCollectionProperties(string[] memory keys) public {211 require(false, stub_error);212 keys;213 dummy = 0;214 }215216 /// Get collection property.217 ///218 /// @dev Throws error if key not found.219 ///220 /// @param key Property key.221 /// @return bytes The property corresponding to the key.222 /// @dev EVM selector for this function is: 0xcf24fd6d,223 /// or in textual repr: collectionProperty(string)224 function collectionProperty(string memory key) public view returns (bytes memory) {225 require(false, stub_error);226 key;227 dummy;228 return hex"";229 }230231 /// Get collection properties.232 ///233 /// @param keys Properties keys. Empty keys for all propertyes.234 /// @return Vector of properties key/value pairs.235 /// @dev EVM selector for this function is: 0x285fb8e6,236 /// or in textual repr: collectionProperties(string[])237 function collectionProperties(string[] memory keys) public view returns (Property[] memory) {238 require(false, stub_error);239 keys;240 dummy;241 return new Property[](0);242 }243244 // /// Set the sponsor of the collection.245 // ///246 // /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.247 // ///248 // /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.249 // /// @dev EVM selector for this function is: 0x7623402e,250 // /// or in textual repr: setCollectionSponsor(address)251 // function setCollectionSponsor(address sponsor) public {252 // require(false, stub_error);253 // sponsor;254 // dummy = 0;255 // }256257 /// Set the sponsor of the collection.258 ///259 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.260 ///261 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.262 /// @dev EVM selector for this function is: 0x84a1d5a8,263 /// or in textual repr: setCollectionSponsorCross((address,uint256))264 function setCollectionSponsorCross(CrossAddress memory sponsor) public {265 require(false, stub_error);266 sponsor;267 dummy = 0;268 }269270 /// Whether there is a pending sponsor.271 /// @dev EVM selector for this function is: 0x058ac185,272 /// or in textual repr: hasCollectionPendingSponsor()273 function hasCollectionPendingSponsor() public view returns (bool) {274 require(false, stub_error);275 dummy;276 return false;277 }278279 /// Collection sponsorship confirmation.280 ///281 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.282 /// @dev EVM selector for this function is: 0x3c50e97a,283 /// or in textual repr: confirmCollectionSponsorship()284 function confirmCollectionSponsorship() public {285 require(false, stub_error);286 dummy = 0;287 }288289 /// Remove collection sponsor.290 /// @dev EVM selector for this function is: 0x6e0326a3,291 /// or in textual repr: removeCollectionSponsor()292 function removeCollectionSponsor() public {293 require(false, stub_error);294 dummy = 0;295 }296297 /// Get current sponsor.298 ///299 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.300 /// @dev EVM selector for this function is: 0x6ec0a9f1,301 /// or in textual repr: collectionSponsor()302 function collectionSponsor() public view returns (CrossAddress memory) {303 require(false, stub_error);304 dummy;305 return CrossAddress(0x0000000000000000000000000000000000000000, 0);306 }307308 /// Get current collection limits.309 ///310 /// @return Array of collection limits311 /// @dev EVM selector for this function is: 0xf63bc572,312 /// or in textual repr: collectionLimits()313 function collectionLimits() public view returns (CollectionLimit[] memory) {314 require(false, stub_error);315 dummy;316 return new CollectionLimit[](0);317 }318319 /// Set limits for the collection.320 /// @dev Throws error if limit not found.321 /// @param limit Some limit.322 /// @dev EVM selector for this function is: 0x2316ee74,323 /// or in textual repr: setCollectionLimit((uint8,(bool,uint256)))324 function setCollectionLimit(CollectionLimit memory limit) public {325 require(false, stub_error);326 limit;327 dummy = 0;328 }329330 /// Get contract address.331 /// @dev EVM selector for this function is: 0xf6b4dfb4,332 /// or in textual repr: contractAddress()333 function contractAddress() public view returns (address) {334 require(false, stub_error);335 dummy;336 return 0x0000000000000000000000000000000000000000;337 }338339 /// Add collection admin.340 /// @param newAdmin Cross account administrator address.341 /// @dev EVM selector for this function is: 0x859aa7d6,342 /// or in textual repr: addCollectionAdminCross((address,uint256))343 function addCollectionAdminCross(CrossAddress memory newAdmin) public {344 require(false, stub_error);345 newAdmin;346 dummy = 0;347 }348349 /// Remove collection admin.350 /// @param admin Cross account administrator address.351 /// @dev EVM selector for this function is: 0x6c0cd173,352 /// or in textual repr: removeCollectionAdminCross((address,uint256))353 function removeCollectionAdminCross(CrossAddress memory admin) public {354 require(false, stub_error);355 admin;356 dummy = 0;357 }358359 // /// Add collection admin.360 // /// @param newAdmin Address of the added administrator.361 // /// @dev EVM selector for this function is: 0x92e462c7,362 // /// or in textual repr: addCollectionAdmin(address)363 // function addCollectionAdmin(address newAdmin) public {364 // require(false, stub_error);365 // newAdmin;366 // dummy = 0;367 // }368369 // /// Remove collection admin.370 // ///371 // /// @param admin Address of the removed administrator.372 // /// @dev EVM selector for this function is: 0xfafd7b42,373 // /// or in textual repr: removeCollectionAdmin(address)374 // function removeCollectionAdmin(address admin) public {375 // require(false, stub_error);376 // admin;377 // dummy = 0;378 // }379380 /// Toggle accessibility of collection nesting.381 ///382 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'383 /// @dev EVM selector for this function is: 0x112d4586,384 /// or in textual repr: setCollectionNesting(bool)385 function setCollectionNesting(bool enable) public {386 require(false, stub_error);387 enable;388 dummy = 0;389 }390391 /// Toggle accessibility of collection nesting.392 ///393 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'394 /// @param collections Addresses of collections that will be available for nesting.395 /// @dev EVM selector for this function is: 0x64872396,396 /// or in textual repr: setCollectionNesting(bool,address[])397 function setCollectionNesting(bool enable, address[] memory collections) public {398 require(false, stub_error);399 enable;400 collections;401 dummy = 0;402 }403404 /// Returns nesting for a collection405 /// @dev EVM selector for this function is: 0x22d25bfe,406 /// or in textual repr: collectionNestingRestrictedCollectionIds()407 function collectionNestingRestrictedCollectionIds() public view returns (CollectionNesting memory) {408 require(false, stub_error);409 dummy;410 return CollectionNesting(false, new uint256[](0));411 }412413 /// Returns permissions for a collection414 /// @dev EVM selector for this function is: 0x5b2eaf4b,415 /// or in textual repr: collectionNestingPermissions()416 function collectionNestingPermissions() public view returns (CollectionNestingPermission[] memory) {417 require(false, stub_error);418 dummy;419 return new CollectionNestingPermission[](0);420 }421422 /// Set the collection access method.423 /// @param mode Access mode424 /// @dev EVM selector for this function is: 0x41835d4c,425 /// or in textual repr: setCollectionAccess(uint8)426 function setCollectionAccess(AccessMode mode) public {427 require(false, stub_error);428 mode;429 dummy = 0;430 }431432 /// Checks that user allowed to operate with collection.433 ///434 /// @param user User address to check.435 /// @dev EVM selector for this function is: 0x91b6df49,436 /// or in textual repr: allowlistedCross((address,uint256))437 function allowlistedCross(CrossAddress memory user) public view returns (bool) {438 require(false, stub_error);439 user;440 dummy;441 return false;442 }443444 // /// Add the user to the allowed list.445 // ///446 // /// @param user Address of a trusted user.447 // /// @dev EVM selector for this function is: 0x67844fe6,448 // /// or in textual repr: addToCollectionAllowList(address)449 // function addToCollectionAllowList(address user) public {450 // require(false, stub_error);451 // user;452 // dummy = 0;453 // }454455 /// Add user to allowed list.456 ///457 /// @param user User cross account address.458 /// @dev EVM selector for this function is: 0xa0184a3a,459 /// or in textual repr: addToCollectionAllowListCross((address,uint256))460 function addToCollectionAllowListCross(CrossAddress memory user) public {461 require(false, stub_error);462 user;463 dummy = 0;464 }465466 // /// Remove the user from the allowed list.467 // ///468 // /// @param user Address of a removed user.469 // /// @dev EVM selector for this function is: 0x85c51acb,470 // /// or in textual repr: removeFromCollectionAllowList(address)471 // function removeFromCollectionAllowList(address user) public {472 // require(false, stub_error);473 // user;474 // dummy = 0;475 // }476477 /// Remove user from allowed list.478 ///479 /// @param user User cross account address.480 /// @dev EVM selector for this function is: 0x09ba452a,481 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))482 function removeFromCollectionAllowListCross(CrossAddress memory user) public {483 require(false, stub_error);484 user;485 dummy = 0;486 }487488 /// Switch permission for minting.489 ///490 /// @param mode Enable if "true".491 /// @dev EVM selector for this function is: 0x00018e84,492 /// or in textual repr: setCollectionMintMode(bool)493 function setCollectionMintMode(bool mode) public {494 require(false, stub_error);495 mode;496 dummy = 0;497 }498499 // /// Check that account is the owner or admin of the collection500 // ///501 // /// @param user account to verify502 // /// @return "true" if account is the owner or admin503 // /// @dev EVM selector for this function is: 0x9811b0c7,504 // /// or in textual repr: isOwnerOrAdmin(address)505 // function isOwnerOrAdmin(address user) public view returns (bool) {506 // require(false, stub_error);507 // user;508 // dummy;509 // return false;510 // }511512 /// Check that account is the owner or admin of the collection513 ///514 /// @param user User cross account to verify515 /// @return "true" if account is the owner or admin516 /// @dev EVM selector for this function is: 0x3e75a905,517 /// or in textual repr: isOwnerOrAdminCross((address,uint256))518 function isOwnerOrAdminCross(CrossAddress memory user) public view returns (bool) {519 require(false, stub_error);520 user;521 dummy;522 return false;523 }524525 /// Returns collection type526 ///527 /// @return `Fungible` or `NFT` or `ReFungible`528 /// @dev EVM selector for this function is: 0xd34b55b8,529 /// or in textual repr: uniqueCollectionType()530 function uniqueCollectionType() public view returns (string memory) {531 require(false, stub_error);532 dummy;533 return "";534 }535536 /// Get collection owner.537 ///538 /// @return Tuble with sponsor address and his substrate mirror.539 /// If address is canonical then substrate mirror is zero and vice versa.540 /// @dev EVM selector for this function is: 0xdf727d3b,541 /// or in textual repr: collectionOwner()542 function collectionOwner() public view returns (CrossAddress memory) {543 require(false, stub_error);544 dummy;545 return CrossAddress(0x0000000000000000000000000000000000000000, 0);546 }547548 // /// Changes collection owner to another account549 // ///550 // /// @dev Owner can be changed only by current owner551 // /// @param newOwner new owner account552 // /// @dev EVM selector for this function is: 0x4f53e226,553 // /// or in textual repr: changeCollectionOwner(address)554 // function changeCollectionOwner(address newOwner) public {555 // require(false, stub_error);556 // newOwner;557 // dummy = 0;558 // }559560 /// Get collection administrators561 ///562 /// @return Vector of tuples with admins address and his substrate mirror.563 /// If address is canonical then substrate mirror is zero and vice versa.564 /// @dev EVM selector for this function is: 0x5813216b,565 /// or in textual repr: collectionAdmins()566 function collectionAdmins() public view returns (CrossAddress[] memory) {567 require(false, stub_error);568 dummy;569 return new CrossAddress[](0);570 }571572 /// Changes collection owner to another account573 ///574 /// @dev Owner can be changed only by current owner575 /// @param newOwner new owner cross account576 /// @dev EVM selector for this function is: 0x6496c497,577 /// or in textual repr: changeCollectionOwnerCross((address,uint256))578 function changeCollectionOwnerCross(CrossAddress memory newOwner) public {579 require(false, stub_error);580 newOwner;581 dummy = 0;582 }583}584585/// Cross account struct586struct CrossAddress {587 address eth;588 uint256 sub;589}590591/// Ethereum representation of `AccessMode` (see [`up_data_structs::AccessMode`]).592enum AccessMode {593 /// Access grant for owner and admins. Used as default.594 Normal,595 /// Like a [`Normal`](AccessMode::Normal) but also users in allow list.596 AllowList597}598599/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) field.600struct CollectionNestingPermission {601 CollectionPermissionField field;602 bool value;603}604605/// Ethereum representation of `NestingPermissions` (see [`up_data_structs::NestingPermissions`]) fields as an enumeration.606enum CollectionPermissionField {607 /// Owner of token can nest tokens under it.608 TokenOwner,609 /// Admin of token collection can nest tokens under token.610 CollectionAdmin611}612613/// Nested collections.614struct CollectionNesting {615 bool token_owner;616 uint256[] ids;617}618619/// [`CollectionLimits`](up_data_structs::CollectionLimits) field representation for EVM.620struct CollectionLimit {621 CollectionLimitField field;622 OptionUint256 value;623}624625/// Optional value626struct OptionUint256 {627 /// Shows the status of accessibility of value628 bool status;629 /// Actual value if `status` is true630 uint256 value;631}632633/// [`CollectionLimits`](up_data_structs::CollectionLimits) fields representation for EVM.634enum CollectionLimitField {635 /// How many tokens can a user have on one account.636 AccountTokenOwnership,637 /// How many bytes of data are available for sponsorship.638 SponsoredDataSize,639 /// In any case, chain default: [`SponsoringRateLimit::SponsoringDisabled`]640 SponsoredDataRateLimit,641 /// How many tokens can be mined into this collection.642 TokenLimit,643 /// Timeouts for transfer sponsoring.644 SponsorTransferTimeout,645 /// Timeout for sponsoring an approval in passed blocks.646 SponsorApproveTimeout,647 /// Whether the collection owner of the collection can send tokens (which belong to other users).648 OwnerCanTransfer,649 /// Can the collection owner burn other people's tokens.650 OwnerCanDestroy,651 /// Is it possible to send tokens from this collection between users.652 TransferEnabled653}654655/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension656/// @dev See https://eips.ethereum.org/EIPS/eip-721657/// @dev the ERC-165 identifier for this interface is 0x5b5e139f658contract ERC721Metadata is Dummy, ERC165 {659 // /// @notice A descriptive name for a collection of NFTs in this contract660 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`661 // /// @dev EVM selector for this function is: 0x06fdde03,662 // /// or in textual repr: name()663 // function name() public view returns (string memory) {664 // require(false, stub_error);665 // dummy;666 // return "";667 // }668669 // /// @notice An abbreviated name for NFTs in this contract670 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`671 // /// @dev EVM selector for this function is: 0x95d89b41,672 // /// or in textual repr: symbol()673 // function symbol() public view returns (string memory) {674 // require(false, stub_error);675 // dummy;676 // return "";677 // }678679 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.680 ///681 /// @dev If the token has a `url` property and it is not empty, it is returned.682 /// Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.683 /// If the collection property `baseURI` is empty or absent, return "" (empty string)684 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix685 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).686 ///687 /// @return token's const_metadata688 /// @dev EVM selector for this function is: 0xc87b56dd,689 /// or in textual repr: tokenURI(uint256)690 function tokenURI(uint256 tokenId) public view returns (string memory) {691 require(false, stub_error);692 tokenId;693 dummy;694 return "";695 }696}697698/// @title ERC721 Token that can be irreversibly burned (destroyed).699/// @dev the ERC-165 identifier for this interface is 0x42966c68700contract ERC721Burnable is Dummy, ERC165 {701 /// @notice Burns a specific ERC721 token.702 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized703 /// operator of the current owner.704 /// @param tokenId The NFT to approve705 /// @dev EVM selector for this function is: 0x42966c68,706 /// or in textual repr: burn(uint256)707 function burn(uint256 tokenId) public {708 require(false, stub_error);709 tokenId;710 dummy = 0;711 }712}713714/// @title ERC721 minting logic.715/// @dev the ERC-165 identifier for this interface is 0x3fd94ea6716contract ERC721UniqueMintable is Dummy, ERC165 {717 /// @notice Function to mint a token.718 /// @param to The new owner719 /// @return uint256 The id of the newly minted token720 /// @dev EVM selector for this function is: 0x6a627842,721 /// or in textual repr: mint(address)722 function mint(address to) public returns (uint256) {723 require(false, stub_error);724 to;725 dummy = 0;726 return 0;727 }728729 // /// @notice Function to mint a token.730 // /// @dev `tokenId` should be obtained with `nextTokenId` method,731 // /// unlike standard, you can't specify it manually732 // /// @param to The new owner733 // /// @param tokenId ID of the minted NFT734 // /// @dev EVM selector for this function is: 0x40c10f19,735 // /// or in textual repr: mint(address,uint256)736 // function mint(address to, uint256 tokenId) public returns (bool) {737 // require(false, stub_error);738 // to;739 // tokenId;740 // dummy = 0;741 // return false;742 // }743744 /// @notice Function to mint token with the given tokenUri.745 /// @param to The new owner746 /// @param tokenUri Token URI that would be stored in the NFT properties747 /// @return uint256 The id of the newly minted token748 /// @dev EVM selector for this function is: 0x45c17782,749 /// or in textual repr: mintWithTokenURI(address,string)750 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {751 require(false, stub_error);752 to;753 tokenUri;754 dummy = 0;755 return 0;756 }757 // /// @notice Function to mint token with the given tokenUri.758 // /// @dev `tokenId` should be obtained with `nextTokenId` method,759 // /// unlike standard, you can't specify it manually760 // /// @param to The new owner761 // /// @param tokenId ID of the minted NFT762 // /// @param tokenUri Token URI that would be stored in the NFT properties763 // /// @dev EVM selector for this function is: 0x50bb4e7f,764 // /// or in textual repr: mintWithTokenURI(address,uint256,string)765 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {766 // require(false, stub_error);767 // to;768 // tokenId;769 // tokenUri;770 // dummy = 0;771 // return false;772 // }773774}775776/// @title Unique extensions for ERC721.777/// @dev the ERC-165 identifier for this interface is 0x307b061a778contract ERC721UniqueExtensions is Dummy, ERC165 {779 /// @notice A descriptive name for a collection of NFTs in this contract780 /// @dev EVM selector for this function is: 0x06fdde03,781 /// or in textual repr: name()782 function name() public view returns (string memory) {783 require(false, stub_error);784 dummy;785 return "";786 }787788 /// @notice An abbreviated name for NFTs in this contract789 /// @dev EVM selector for this function is: 0x95d89b41,790 /// or in textual repr: symbol()791 function symbol() public view returns (string memory) {792 require(false, stub_error);793 dummy;794 return "";795 }796797 /// @notice A description for the collection.798 /// @dev EVM selector for this function is: 0x7284e416,799 /// or in textual repr: description()800 function description() public view returns (string memory) {801 require(false, stub_error);802 dummy;803 return "";804 }805806 // /// Returns the owner (in cross format) of the token.807 // ///808 // /// @param tokenId Id for the token.809 // /// @dev EVM selector for this function is: 0x2b29dace,810 // /// or in textual repr: crossOwnerOf(uint256)811 // function crossOwnerOf(uint256 tokenId) public view returns (CrossAddress memory) {812 // require(false, stub_error);813 // tokenId;814 // dummy;815 // return CrossAddress(0x0000000000000000000000000000000000000000,0);816 // }817818 /// Returns the owner (in cross format) of the token.819 ///820 /// @param tokenId Id for the token.821 /// @dev EVM selector for this function is: 0xcaa3a4d0,822 /// or in textual repr: ownerOfCross(uint256)823 function ownerOfCross(uint256 tokenId) public view returns (CrossAddress memory) {824 require(false, stub_error);825 tokenId;826 dummy;827 return CrossAddress(0x0000000000000000000000000000000000000000, 0);828 }829830 /// @notice Count all NFTs assigned to an owner831 /// @param owner An cross address for whom to query the balance832 /// @return The number of NFTs owned by `owner`, possibly zero833 /// @dev EVM selector for this function is: 0xec069398,834 /// or in textual repr: balanceOfCross((address,uint256))835 function balanceOfCross(CrossAddress memory owner) public view returns (uint256) {836 require(false, stub_error);837 owner;838 dummy;839 return 0;840 }841842 /// Returns the token properties.843 ///844 /// @param tokenId Id for the token.845 /// @param keys Properties keys. Empty keys for all propertyes.846 /// @return Vector of properties key/value pairs.847 /// @dev EVM selector for this function is: 0xe07ede7e,848 /// or in textual repr: properties(uint256,string[])849 function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {850 require(false, stub_error);851 tokenId;852 keys;853 dummy;854 return new Property[](0);855 }856857 /// @notice Set or reaffirm the approved address for an NFT858 /// @dev The zero address indicates there is no approved address.859 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized860 /// operator of the current owner.861 /// @param approved The new substrate address approved NFT controller862 /// @param tokenId The NFT to approve863 /// @dev EVM selector for this function is: 0x0ecd0ab0,864 /// or in textual repr: approveCross((address,uint256),uint256)865 function approveCross(CrossAddress memory approved, uint256 tokenId) public {866 require(false, stub_error);867 approved;868 tokenId;869 dummy = 0;870 }871872 /// @notice Transfer ownership of an NFT873 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`874 /// is the zero address. Throws if `tokenId` is not a valid NFT.875 /// @param to The new owner876 /// @param tokenId The NFT to transfer877 /// @dev EVM selector for this function is: 0xa9059cbb,878 /// or in textual repr: transfer(address,uint256)879 function transfer(address to, uint256 tokenId) public {880 require(false, stub_error);881 to;882 tokenId;883 dummy = 0;884 }885886 /// @notice Transfer ownership of an NFT887 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`888 /// is the zero address. Throws if `tokenId` is not a valid NFT.889 /// @param to The new owner890 /// @param tokenId The NFT to transfer891 /// @dev EVM selector for this function is: 0x2ada85ff,892 /// or in textual repr: transferCross((address,uint256),uint256)893 function transferCross(CrossAddress memory to, uint256 tokenId) public {894 require(false, stub_error);895 to;896 tokenId;897 dummy = 0;898 }899900 /// @notice Transfer ownership of an NFT from cross account address to cross account address901 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`902 /// is the zero address. Throws if `tokenId` is not a valid NFT.903 /// @param from Cross acccount address of current owner904 /// @param to Cross acccount address of new owner905 /// @param tokenId The NFT to transfer906 /// @dev EVM selector for this function is: 0xd5cf430b,907 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)908 function transferFromCross(909 CrossAddress memory from,910 CrossAddress memory to,911 uint256 tokenId912 ) public {913 require(false, stub_error);914 from;915 to;916 tokenId;917 dummy = 0;918 }919920 // /// @notice Burns a specific ERC721 token.921 // /// @dev Throws unless `msg.sender` is the current owner or an authorized922 // /// operator for this NFT. Throws if `from` is not the current owner. Throws923 // /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.924 // /// @param from The current owner of the NFT925 // /// @param tokenId The NFT to transfer926 // /// @dev EVM selector for this function is: 0x79cc6790,927 // /// or in textual repr: burnFrom(address,uint256)928 // function burnFrom(address from, uint256 tokenId) public {929 // require(false, stub_error);930 // from;931 // tokenId;932 // dummy = 0;933 // }934935 /// @notice Burns a specific ERC721 token.936 /// @dev Throws unless `msg.sender` is the current owner or an authorized937 /// operator for this NFT. Throws if `from` is not the current owner. Throws938 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.939 /// @param from The current owner of the NFT940 /// @param tokenId The NFT to transfer941 /// @dev EVM selector for this function is: 0xbb2f5a58,942 /// or in textual repr: burnFromCross((address,uint256),uint256)943 function burnFromCross(CrossAddress memory from, uint256 tokenId) public {944 require(false, stub_error);945 from;946 tokenId;947 dummy = 0;948 }949950 /// @notice Returns next free NFT ID.951 /// @dev EVM selector for this function is: 0x75794a3c,952 /// or in textual repr: nextTokenId()953 function nextTokenId() public view returns (uint256) {954 require(false, stub_error);955 dummy;956 return 0;957 }958959 // /// @notice Function to mint multiple tokens.960 // /// @dev `tokenIds` should be an array of consecutive numbers and first number961 // /// should be obtained with `nextTokenId` method962 // /// @param to The new owner963 // /// @param tokenIds IDs of the minted NFTs964 // /// @dev EVM selector for this function is: 0x44a9945e,965 // /// or in textual repr: mintBulk(address,uint256[])966 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {967 // require(false, stub_error);968 // to;969 // tokenIds;970 // dummy = 0;971 // return false;972 // }973974 // /// @notice Function to mint multiple tokens with the given tokenUris.975 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive976 // /// numbers and first number should be obtained with `nextTokenId` method977 // /// @param to The new owner978 // /// @param tokens array of pairs of token ID and token URI for minted tokens979 // /// @dev EVM selector for this function is: 0x36543006,980 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])981 // function mintBulkWithTokenURI(address to, TokenUri[] memory tokens) public returns (bool) {982 // require(false, stub_error);983 // to;984 // tokens;985 // dummy = 0;986 // return false;987 // }988989 /// @notice Function to mint a token.990 /// @param to The new owner crossAccountId991 /// @param properties Properties of minted token992 /// @return uint256 The id of the newly minted token993 /// @dev EVM selector for this function is: 0xb904db03,994 /// or in textual repr: mintCross((address,uint256),(string,bytes)[])995 function mintCross(CrossAddress memory to, Property[] memory properties) public returns (uint256) {996 require(false, stub_error);997 to;998 properties;999 dummy = 0;1000 return 0;1001 }10021003 /// @notice Returns collection helper contract address1004 /// @dev EVM selector for this function is: 0x1896cce6,1005 /// or in textual repr: collectionHelperAddress()1006 function collectionHelperAddress() public view returns (address) {1007 require(false, stub_error);1008 dummy;1009 return 0x0000000000000000000000000000000000000000;1010 }1011}10121013/// Data for creation token with uri.1014struct TokenUri {1015 /// Id of new token.1016 uint256 id;1017 /// Uri of new token.1018 string uri;1019}10201021/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension1022/// @dev See https://eips.ethereum.org/EIPS/eip-7211023/// @dev the ERC-165 identifier for this interface is 0x780e9d631024contract ERC721Enumerable is Dummy, ERC165 {1025 /// @notice Enumerate valid NFTs1026 /// @param index A counter less than `totalSupply()`1027 /// @return The token identifier for the `index`th NFT,1028 /// (sort order not specified)1029 /// @dev EVM selector for this function is: 0x4f6ccce7,1030 /// or in textual repr: tokenByIndex(uint256)1031 function tokenByIndex(uint256 index) public view returns (uint256) {1032 require(false, stub_error);1033 index;1034 dummy;1035 return 0;1036 }10371038 /// @dev Not implemented1039 /// @dev EVM selector for this function is: 0x2f745c59,1040 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)1041 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1042 require(false, stub_error);1043 owner;1044 index;1045 dummy;1046 return 0;1047 }10481049 /// @notice Count NFTs tracked by this contract1050 /// @return A count of valid NFTs tracked by this contract, where each one of1051 /// them has an assigned and queryable owner not equal to the zero address1052 /// @dev EVM selector for this function is: 0x18160ddd,1053 /// or in textual repr: totalSupply()1054 function totalSupply() public view returns (uint256) {1055 require(false, stub_error);1056 dummy;1057 return 0;1058 }1059}10601061/// @dev inlined interface1062contract ERC721Events {1063 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1064 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1065 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1066}10671068/// @title ERC-721 Non-Fungible Token Standard1069/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1070/// @dev the ERC-165 identifier for this interface is 0x80ac58cd1071contract ERC721 is Dummy, ERC165, ERC721Events {1072 /// @notice Count all NFTs assigned to an owner1073 /// @dev NFTs assigned to the zero address are considered invalid, and this1074 /// function throws for queries about the zero address.1075 /// @param owner An address for whom to query the balance1076 /// @return The number of NFTs owned by `owner`, possibly zero1077 /// @dev EVM selector for this function is: 0x70a08231,1078 /// or in textual repr: balanceOf(address)1079 function balanceOf(address owner) public view returns (uint256) {1080 require(false, stub_error);1081 owner;1082 dummy;1083 return 0;1084 }10851086 /// @notice Find the owner of an NFT1087 /// @dev NFTs assigned to zero address are considered invalid, and queries1088 /// about them do throw.1089 /// @param tokenId The identifier for an NFT1090 /// @return The address of the owner of the NFT1091 /// @dev EVM selector for this function is: 0x6352211e,1092 /// or in textual repr: ownerOf(uint256)1093 function ownerOf(uint256 tokenId) public view returns (address) {1094 require(false, stub_error);1095 tokenId;1096 dummy;1097 return 0x0000000000000000000000000000000000000000;1098 }10991100 /// @dev Not implemented1101 /// @dev EVM selector for this function is: 0xb88d4fde,1102 /// or in textual repr: safeTransferFrom(address,address,uint256,bytes)1103 function safeTransferFrom(1104 address from,1105 address to,1106 uint256 tokenId,1107 bytes memory data1108 ) public {1109 require(false, stub_error);1110 from;1111 to;1112 tokenId;1113 data;1114 dummy = 0;1115 }11161117 /// @dev Not implemented1118 /// @dev EVM selector for this function is: 0x42842e0e,1119 /// or in textual repr: safeTransferFrom(address,address,uint256)1120 function safeTransferFrom(1121 address from,1122 address to,1123 uint256 tokenId1124 ) public {1125 require(false, stub_error);1126 from;1127 to;1128 tokenId;1129 dummy = 0;1130 }11311132 /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1133 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1134 /// THEY MAY BE PERMANENTLY LOST1135 /// @dev Throws unless `msg.sender` is the current owner or an authorized1136 /// operator for this NFT. Throws if `from` is not the current owner. Throws1137 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1138 /// @param from The current owner of the NFT1139 /// @param to The new owner1140 /// @param tokenId The NFT to transfer1141 /// @dev EVM selector for this function is: 0x23b872dd,1142 /// or in textual repr: transferFrom(address,address,uint256)1143 function transferFrom(1144 address from,1145 address to,1146 uint256 tokenId1147 ) public {1148 require(false, stub_error);1149 from;1150 to;1151 tokenId;1152 dummy = 0;1153 }11541155 /// @notice Set or reaffirm the approved address for an NFT1156 /// @dev The zero address indicates there is no approved address.1157 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1158 /// operator of the current owner.1159 /// @param approved The new approved NFT controller1160 /// @param tokenId The NFT to approve1161 /// @dev EVM selector for this function is: 0x095ea7b3,1162 /// or in textual repr: approve(address,uint256)1163 function approve(address approved, uint256 tokenId) public {1164 require(false, stub_error);1165 approved;1166 tokenId;1167 dummy = 0;1168 }11691170 /// @notice Sets or unsets the approval of a given operator.1171 /// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1172 /// @param operator Operator1173 /// @param approved Should operator status be granted or revoked?1174 /// @dev EVM selector for this function is: 0xa22cb465,1175 /// or in textual repr: setApprovalForAll(address,bool)1176 function setApprovalForAll(address operator, bool approved) public {1177 require(false, stub_error);1178 operator;1179 approved;1180 dummy = 0;1181 }11821183 /// @notice Get the approved address for a single NFT1184 /// @dev Throws if `tokenId` is not a valid NFT1185 /// @param tokenId The NFT to find the approved address for1186 /// @return The approved address for this NFT, or the zero address if there is none1187 /// @dev EVM selector for this function is: 0x081812fc,1188 /// or in textual repr: getApproved(uint256)1189 function getApproved(uint256 tokenId) public view returns (address) {1190 require(false, stub_error);1191 tokenId;1192 dummy;1193 return 0x0000000000000000000000000000000000000000;1194 }11951196 /// @notice Tells whether the given `owner` approves the `operator`.1197 /// @dev EVM selector for this function is: 0xe985e9c5,1198 /// or in textual repr: isApprovedForAll(address,address)1199 function isApprovedForAll(address owner, address operator) public view returns (bool) {1200 require(false, stub_error);1201 owner;1202 operator;1203 dummy;1204 return false;1205 }1206}12071208contract UniqueNFT is1209 Dummy,1210 ERC165,1211 ERC721,1212 ERC721Enumerable,1213 ERC721UniqueExtensions,1214 ERC721UniqueMintable,1215 ERC721Burnable,1216 ERC721Metadata,1217 Collection,1218 TokenProperties1219{}