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 RFT owner, or an authorized703 /// operator of the current owner.704 /// @param tokenId The RFT 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 RFT734 // /// @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 RFT762 // /// @param tokenUri Token URI that would be stored in the RFT 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 0x95c0f66c778contract 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 RFTs assigned to an owner831 /// @param owner An cross address for whom to query the balance832 /// @return The number of RFTs 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 Transfer ownership of an RFT858 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`859 /// is the zero address. Throws if `tokenId` is not a valid RFT.860 /// Throws if RFT pieces have multiple owners.861 /// @param to The new owner862 /// @param tokenId The RFT to transfer863 /// @dev EVM selector for this function is: 0xa9059cbb,864 /// or in textual repr: transfer(address,uint256)865 function transfer(address to, uint256 tokenId) public {866 require(false, stub_error);867 to;868 tokenId;869 dummy = 0;870 }871872 /// @notice Transfer ownership of an RFT873 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`874 /// is the zero address. Throws if `tokenId` is not a valid RFT.875 /// Throws if RFT pieces have multiple owners.876 /// @param to The new owner877 /// @param tokenId The RFT to transfer878 /// @dev EVM selector for this function is: 0x2ada85ff,879 /// or in textual repr: transferCross((address,uint256),uint256)880 function transferCross(CrossAddress memory to, uint256 tokenId) public {881 require(false, stub_error);882 to;883 tokenId;884 dummy = 0;885 }886887 /// @notice Transfer ownership of an RFT888 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`889 /// is the zero address. Throws if `tokenId` is not a valid RFT.890 /// Throws if RFT pieces have multiple owners.891 /// @param to The new owner892 /// @param tokenId The RFT to transfer893 /// @dev EVM selector for this function is: 0xd5cf430b,894 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)895 function transferFromCross(896 CrossAddress memory from,897 CrossAddress memory to,898 uint256 tokenId899 ) public {900 require(false, stub_error);901 from;902 to;903 tokenId;904 dummy = 0;905 }906907 // /// @notice Burns a specific ERC721 token.908 // /// @dev Throws unless `msg.sender` is the current owner or an authorized909 // /// operator for this RFT. Throws if `from` is not the current owner. Throws910 // /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.911 // /// Throws if RFT pieces have multiple owners.912 // /// @param from The current owner of the RFT913 // /// @param tokenId The RFT to transfer914 // /// @dev EVM selector for this function is: 0x79cc6790,915 // /// or in textual repr: burnFrom(address,uint256)916 // function burnFrom(address from, uint256 tokenId) public {917 // require(false, stub_error);918 // from;919 // tokenId;920 // dummy = 0;921 // }922923 /// @notice Burns a specific ERC721 token.924 /// @dev Throws unless `msg.sender` is the current owner or an authorized925 /// operator for this RFT. Throws if `from` is not the current owner. Throws926 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.927 /// Throws if RFT pieces have multiple owners.928 /// @param from The current owner of the RFT929 /// @param tokenId The RFT to transfer930 /// @dev EVM selector for this function is: 0xbb2f5a58,931 /// or in textual repr: burnFromCross((address,uint256),uint256)932 function burnFromCross(CrossAddress memory from, uint256 tokenId) public {933 require(false, stub_error);934 from;935 tokenId;936 dummy = 0;937 }938939 /// @notice Returns next free RFT ID.940 /// @dev EVM selector for this function is: 0x75794a3c,941 /// or in textual repr: nextTokenId()942 function nextTokenId() public view returns (uint256) {943 require(false, stub_error);944 dummy;945 return 0;946 }947948 // /// @notice Function to mint multiple tokens.949 // /// @dev `tokenIds` should be an array of consecutive numbers and first number950 // /// should be obtained with `nextTokenId` method951 // /// @param to The new owner952 // /// @param tokenIds IDs of the minted RFTs953 // /// @dev EVM selector for this function is: 0x44a9945e,954 // /// or in textual repr: mintBulk(address,uint256[])955 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {956 // require(false, stub_error);957 // to;958 // tokenIds;959 // dummy = 0;960 // return false;961 // }962963 // /// @notice Function to mint multiple tokens with the given tokenUris.964 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive965 // /// numbers and first number should be obtained with `nextTokenId` method966 // /// @param to The new owner967 // /// @param tokens array of pairs of token ID and token URI for minted tokens968 // /// @dev EVM selector for this function is: 0x36543006,969 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])970 // function mintBulkWithTokenURI(address to, TokenUri[] memory tokens) public returns (bool) {971 // require(false, stub_error);972 // to;973 // tokens;974 // dummy = 0;975 // return false;976 // }977978 /// @notice Function to mint a token.979 /// @param to The new owner crossAccountId980 /// @param properties Properties of minted token981 /// @return uint256 The id of the newly minted token982 /// @dev EVM selector for this function is: 0xb904db03,983 /// or in textual repr: mintCross((address,uint256),(string,bytes)[])984 function mintCross(CrossAddress memory to, Property[] memory properties) public returns (uint256) {985 require(false, stub_error);986 to;987 properties;988 dummy = 0;989 return 0;990 }991992 /// Returns EVM address for refungible token993 ///994 /// @param token ID of the token995 /// @dev EVM selector for this function is: 0xab76fac6,996 /// or in textual repr: tokenContractAddress(uint256)997 function tokenContractAddress(uint256 token) public view returns (address) {998 require(false, stub_error);999 token;1000 dummy;1001 return 0x0000000000000000000000000000000000000000;1002 }10031004 /// @notice Returns collection helper contract address1005 /// @dev EVM selector for this function is: 0x1896cce6,1006 /// or in textual repr: collectionHelperAddress()1007 function collectionHelperAddress() public view returns (address) {1008 require(false, stub_error);1009 dummy;1010 return 0x0000000000000000000000000000000000000000;1011 }1012}10131014/// Data for creation token with uri.1015struct TokenUri {1016 /// Id of new token.1017 uint256 id;1018 /// Uri of new token.1019 string uri;1020}10211022/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension1023/// @dev See https://eips.ethereum.org/EIPS/eip-7211024/// @dev the ERC-165 identifier for this interface is 0x780e9d631025contract ERC721Enumerable is Dummy, ERC165 {1026 /// @notice Enumerate valid RFTs1027 /// @param index A counter less than `totalSupply()`1028 /// @return The token identifier for the `index`th NFT,1029 /// (sort order not specified)1030 /// @dev EVM selector for this function is: 0x4f6ccce7,1031 /// or in textual repr: tokenByIndex(uint256)1032 function tokenByIndex(uint256 index) public view returns (uint256) {1033 require(false, stub_error);1034 index;1035 dummy;1036 return 0;1037 }10381039 /// Not implemented1040 /// @dev EVM selector for this function is: 0x2f745c59,1041 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)1042 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {1043 require(false, stub_error);1044 owner;1045 index;1046 dummy;1047 return 0;1048 }10491050 /// @notice Count RFTs tracked by this contract1051 /// @return A count of valid RFTs tracked by this contract, where each one of1052 /// them has an assigned and queryable owner not equal to the zero address1053 /// @dev EVM selector for this function is: 0x18160ddd,1054 /// or in textual repr: totalSupply()1055 function totalSupply() public view returns (uint256) {1056 require(false, stub_error);1057 dummy;1058 return 0;1059 }1060}10611062/// @dev inlined interface1063contract ERC721Events {1064 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);1065 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);1066 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);1067}10681069/// @title ERC-721 Non-Fungible Token Standard1070/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md1071/// @dev the ERC-165 identifier for this interface is 0x80ac58cd1072contract ERC721 is Dummy, ERC165, ERC721Events {1073 /// @notice Count all RFTs assigned to an owner1074 /// @dev RFTs assigned to the zero address are considered invalid, and this1075 /// function throws for queries about the zero address.1076 /// @param owner An address for whom to query the balance1077 /// @return The number of RFTs owned by `owner`, possibly zero1078 /// @dev EVM selector for this function is: 0x70a08231,1079 /// or in textual repr: balanceOf(address)1080 function balanceOf(address owner) public view returns (uint256) {1081 require(false, stub_error);1082 owner;1083 dummy;1084 return 0;1085 }10861087 /// @notice Find the owner of an RFT1088 /// @dev RFTs assigned to zero address are considered invalid, and queries1089 /// about them do throw.1090 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for1091 /// the tokens that are partially owned.1092 /// @param tokenId The identifier for an RFT1093 /// @return The address of the owner of the RFT1094 /// @dev EVM selector for this function is: 0x6352211e,1095 /// or in textual repr: ownerOf(uint256)1096 function ownerOf(uint256 tokenId) public view returns (address) {1097 require(false, stub_error);1098 tokenId;1099 dummy;1100 return 0x0000000000000000000000000000000000000000;1101 }11021103 /// @dev Not implemented1104 /// @dev EVM selector for this function is: 0xb88d4fde,1105 /// or in textual repr: safeTransferFrom(address,address,uint256,bytes)1106 function safeTransferFrom(1107 address from,1108 address to,1109 uint256 tokenId,1110 bytes memory data1111 ) public {1112 require(false, stub_error);1113 from;1114 to;1115 tokenId;1116 data;1117 dummy = 0;1118 }11191120 /// @dev Not implemented1121 /// @dev EVM selector for this function is: 0x42842e0e,1122 /// or in textual repr: safeTransferFrom(address,address,uint256)1123 function safeTransferFrom(1124 address from,1125 address to,1126 uint256 tokenId1127 ) public {1128 require(false, stub_error);1129 from;1130 to;1131 tokenId;1132 dummy = 0;1133 }11341135 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE1136 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1137 /// THEY MAY BE PERMANENTLY LOST1138 /// @dev Throws unless `msg.sender` is the current owner or an authorized1139 /// operator for this RFT. Throws if `from` is not the current owner. Throws1140 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.1141 /// Throws if RFT pieces have multiple owners.1142 /// @param from The current owner of the NFT1143 /// @param to The new owner1144 /// @param tokenId The NFT to transfer1145 /// @dev EVM selector for this function is: 0x23b872dd,1146 /// or in textual repr: transferFrom(address,address,uint256)1147 function transferFrom(1148 address from,1149 address to,1150 uint256 tokenId1151 ) public {1152 require(false, stub_error);1153 from;1154 to;1155 tokenId;1156 dummy = 0;1157 }11581159 /// @dev Not implemented1160 /// @dev EVM selector for this function is: 0x095ea7b3,1161 /// or in textual repr: approve(address,uint256)1162 function approve(address approved, uint256 tokenId) public {1163 require(false, stub_error);1164 approved;1165 tokenId;1166 dummy = 0;1167 }11681169 /// @notice Sets or unsets the approval of a given operator.1170 /// The `operator` is allowed to transfer all token pieces of the `caller` on their behalf.1171 /// @param operator Operator1172 /// @param approved Should operator status be granted or revoked?1173 /// @dev EVM selector for this function is: 0xa22cb465,1174 /// or in textual repr: setApprovalForAll(address,bool)1175 function setApprovalForAll(address operator, bool approved) public {1176 require(false, stub_error);1177 operator;1178 approved;1179 dummy = 0;1180 }11811182 /// @dev Not implemented1183 /// @dev EVM selector for this function is: 0x081812fc,1184 /// or in textual repr: getApproved(uint256)1185 function getApproved(uint256 tokenId) public view returns (address) {1186 require(false, stub_error);1187 tokenId;1188 dummy;1189 return 0x0000000000000000000000000000000000000000;1190 }11911192 /// @notice Tells whether the given `owner` approves the `operator`.1193 /// @dev EVM selector for this function is: 0xe985e9c5,1194 /// or in textual repr: isApprovedForAll(address,address)1195 function isApprovedForAll(address owner, address operator) public view returns (bool) {1196 require(false, stub_error);1197 owner;1198 operator;1199 dummy;1200 return false;1201 }1202}12031204contract UniqueRefungible is1205 Dummy,1206 ERC165,1207 ERC721,1208 ERC721Enumerable,1209 ERC721UniqueExtensions,1210 ERC721UniqueMintable,1211 ERC721Burnable,1212 ERC721Metadata,1213 Collection,1214 TokenProperties1215{}