1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56// Anonymous struct7struct Tuple0 {8 uint256 field_0;9 string field_1;10}1112// Common stubs holder13contract Dummy {14 uint8 dummy;15 string stub_error = "this contract is implemented in native";16}1718contract ERC165 is Dummy {19 function supportsInterface(bytes4 interfaceID)20 external21 view22 returns (bool)23 {24 require(false, stub_error);25 interfaceID;26 return true;27 }28}2930// Inline31contract ERC721Events {32 event Transfer(33 address indexed from,34 address indexed to,35 uint256 indexed tokenId36 );37 event Approval(38 address indexed owner,39 address indexed approved,40 uint256 indexed tokenId41 );42 event ApprovalForAll(43 address indexed owner,44 address indexed operator,45 bool approved46 );47}4849// Inline50contract ERC721MintableEvents {51 event MintingFinished();52}5354// Selector: 4136937755contract TokenProperties is Dummy, ERC165 {56 // @notice Set permissions for token property.57 // @dev Throws error if `msg.sender` is not admin or owner of the collection.58 // @param key Property key.59 // @param is_mutable Permission to mutate property.60 // @param collection_admin Permission to mutate property by collection admin if property is mutable.61 // @param token_owner Permission to mutate property by token owner if property is mutable.62 //63 // Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa64 function setTokenPropertyPermission(65 string memory key,66 bool isMutable,67 bool collectionAdmin,68 bool tokenOwner69 ) public {70 require(false, stub_error);71 key;72 isMutable;73 collectionAdmin;74 tokenOwner;75 dummy = 0;76 }7778 // @notice Set token property value.79 // @dev Throws error if `msg.sender` has no permission to edit the property.80 // @param token_id ID of the token.81 // @param key Property key.82 // @param value Property value.83 //84 // Selector: setProperty(uint256,string,bytes) 1752d67b85 function setProperty(86 uint256 tokenId,87 string memory key,88 bytes memory value89 ) public {90 require(false, stub_error);91 tokenId;92 key;93 value;94 dummy = 0;95 }9697 // @notice Delete token property value.98 // @dev Throws error if `msg.sender` has no permission to edit the property.99 // @param token_id ID of the token.100 // @param key Property key.101 //102 // Selector: deleteProperty(uint256,string) 066111d1103 function deleteProperty(uint256 tokenId, string memory key) public {104 require(false, stub_error);105 tokenId;106 key;107 dummy = 0;108 }109110 // @notice Get token property value.111 // @dev Throws error if key not found112 // @param token_id ID of the token.113 // @param key Property key.114 //115 // Selector: property(uint256,string) 7228c327116 function property(uint256 tokenId, string memory key)117 public118 view119 returns (bytes memory)120 {121 require(false, stub_error);122 tokenId;123 key;124 dummy;125 return hex"";126 }127}128129// Selector: 42966c68130contract ERC721Burnable is Dummy, ERC165 {131 // @notice Burns a specific ERC721 token.132 // @dev Throws unless `msg.sender` is the current NFT owner, or an authorized133 // operator of the current owner.134 // @param tokenId The NFT to approve135 //136 // Selector: burn(uint256) 42966c68137 function burn(uint256 tokenId) public {138 require(false, stub_error);139 tokenId;140 dummy = 0;141 }142}143144// Selector: 58800161145contract ERC721 is Dummy, ERC165, ERC721Events {146 // @notice Count all NFTs assigned to an owner147 // @dev NFTs assigned to the zero address are considered invalid, and this148 // function throws for queries about the zero address.149 // @param _owner An address for whom to query the balance150 // @return The number of NFTs owned by `_owner`, possibly zero151 //152 // Selector: balanceOf(address) 70a08231153 function balanceOf(address owner) public view returns (uint256) {154 require(false, stub_error);155 owner;156 dummy;157 return 0;158 }159160 // @notice Find the owner of an NFT161 // @dev NFTs assigned to zero address are considered invalid, and queries162 // about them do throw.163 // @param _tokenId The identifier for an NFT164 // @return The address of the owner of the NFT165 //166 // Selector: ownerOf(uint256) 6352211e167 function ownerOf(uint256 tokenId) public view returns (address) {168 require(false, stub_error);169 tokenId;170 dummy;171 return 0x0000000000000000000000000000000000000000;172 }173174 // @dev Not implemented175 //176 // Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672177 function safeTransferFromWithData(178 address from,179 address to,180 uint256 tokenId,181 bytes memory data182 ) public {183 require(false, stub_error);184 from;185 to;186 tokenId;187 data;188 dummy = 0;189 }190191 // @dev Not implemented192 //193 // Selector: safeTransferFrom(address,address,uint256) 42842e0e194 function safeTransferFrom(195 address from,196 address to,197 uint256 tokenId198 ) public {199 require(false, stub_error);200 from;201 to;202 tokenId;203 dummy = 0;204 }205206 // @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE207 // TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE208 // THEY MAY BE PERMANENTLY LOST209 // @dev Throws unless `msg.sender` is the current owner or an authorized210 // operator for this NFT. Throws if `from` is not the current owner. Throws211 // if `to` is the zero address. Throws if `tokenId` is not a valid NFT.212 // @param from The current owner of the NFT213 // @param to The new owner214 // @param tokenId The NFT to transfer215 // @param _value Not used for an NFT216 //217 // Selector: transferFrom(address,address,uint256) 23b872dd218 function transferFrom(219 address from,220 address to,221 uint256 tokenId222 ) public {223 require(false, stub_error);224 from;225 to;226 tokenId;227 dummy = 0;228 }229230 // @notice Set or reaffirm the approved address for an NFT231 // @dev The zero address indicates there is no approved address.232 // @dev Throws unless `msg.sender` is the current NFT owner, or an authorized233 // operator of the current owner.234 // @param approved The new approved NFT controller235 // @param tokenId The NFT to approve236 //237 // Selector: approve(address,uint256) 095ea7b3238 function approve(address approved, uint256 tokenId) public {239 require(false, stub_error);240 approved;241 tokenId;242 dummy = 0;243 }244245 // @dev Not implemented246 //247 // Selector: setApprovalForAll(address,bool) a22cb465248 function setApprovalForAll(address operator, bool approved) public {249 require(false, stub_error);250 operator;251 approved;252 dummy = 0;253 }254255 // @dev Not implemented256 //257 // Selector: getApproved(uint256) 081812fc258 function getApproved(uint256 tokenId) public view returns (address) {259 require(false, stub_error);260 tokenId;261 dummy;262 return 0x0000000000000000000000000000000000000000;263 }264265 // @dev Not implemented266 //267 // Selector: isApprovedForAll(address,address) e985e9c5268 function isApprovedForAll(address owner, address operator)269 public270 view271 returns (address)272 {273 require(false, stub_error);274 owner;275 operator;276 dummy;277 return 0x0000000000000000000000000000000000000000;278 }279}280281// Selector: 5b5e139f282contract ERC721Metadata is Dummy, ERC165 {283 // @notice A descriptive name for a collection of NFTs in this contract284 //285 // Selector: name() 06fdde03286 function name() public view returns (string memory) {287 require(false, stub_error);288 dummy;289 return "";290 }291292 // @notice An abbreviated name for NFTs in this contract293 //294 // Selector: symbol() 95d89b41295 function symbol() public view returns (string memory) {296 require(false, stub_error);297 dummy;298 return "";299 }300301 // @notice A distinct Uniform Resource Identifier (URI) for a given asset.302 // @dev Throws if `tokenId` is not a valid NFT. URIs are defined in RFC303 // 3986. The URI may point to a JSON file that conforms to the "ERC721304 // Metadata JSON Schema".305 // @return token's const_metadata306 //307 // Selector: tokenURI(uint256) c87b56dd308 function tokenURI(uint256 tokenId) public view returns (string memory) {309 require(false, stub_error);310 tokenId;311 dummy;312 return "";313 }314}315316// Selector: 68ccfe89317contract ERC721Mintable is Dummy, ERC165, ERC721MintableEvents {318 // Selector: mintingFinished() 05d2035b319 function mintingFinished() public view returns (bool) {320 require(false, stub_error);321 dummy;322 return false;323 }324325 // @notice Function to mint token.326 // @dev `tokenId` should be obtained with `nextTokenId` method,327 // unlike standard, you can't specify it manually328 // @param to The new owner329 // @param tokenId ID of the minted NFT330 //331 // Selector: mint(address,uint256) 40c10f19332 function mint(address to, uint256 tokenId) public returns (bool) {333 require(false, stub_error);334 to;335 tokenId;336 dummy = 0;337 return false;338 }339340 // @notice Function to mint token with the given tokenUri.341 // @dev `tokenId` should be obtained with `nextTokenId` method,342 // unlike standard, you can't specify it manually343 // @param to The new owner344 // @param tokenId ID of the minted NFT345 // @param tokenUri Token URI that would be stored in the NFT properties346 //347 // Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f348 function mintWithTokenURI(349 address to,350 uint256 tokenId,351 string memory tokenUri352 ) public returns (bool) {353 require(false, stub_error);354 to;355 tokenId;356 tokenUri;357 dummy = 0;358 return false;359 }360361 // @dev Not implemented362 //363 // Selector: finishMinting() 7d64bcb4364 function finishMinting() public returns (bool) {365 require(false, stub_error);366 dummy = 0;367 return false;368 }369}370371// Selector: 780e9d63372contract ERC721Enumerable is Dummy, ERC165 {373 // @notice Enumerate valid NFTs374 // @dev Throws if `index` >= `totalSupply()`.375 // @param index A counter less than `totalSupply()`376 // @return The token identifier for the `index`th NFT,377 // (sort order not specified)378 //379 // Selector: tokenByIndex(uint256) 4f6ccce7380 function tokenByIndex(uint256 index) public view returns (uint256) {381 require(false, stub_error);382 index;383 dummy;384 return 0;385 }386387 // @dev Not implemented388 //389 // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59390 function tokenOfOwnerByIndex(address owner, uint256 index)391 public392 view393 returns (uint256)394 {395 require(false, stub_error);396 owner;397 index;398 dummy;399 return 0;400 }401402 // @notice Count NFTs tracked by this contract403 // @return A count of valid NFTs tracked by this contract, where each one of404 // them has an assigned and queryable owner not equal to the zero address405 //406 // Selector: totalSupply() 18160ddd407 function totalSupply() public view returns (uint256) {408 require(false, stub_error);409 dummy;410 return 0;411 }412}413414// Selector: 7d9262e6415contract Collection is Dummy, ERC165 {416 // Selector: setCollectionProperty(string,bytes) 2f073f66417 function setCollectionProperty(string memory key, bytes memory value)418 public419 {420 require(false, stub_error);421 key;422 value;423 dummy = 0;424 }425426 // Selector: deleteCollectionProperty(string) 7b7debce427 function deleteCollectionProperty(string memory key) public {428 require(false, stub_error);429 key;430 dummy = 0;431 }432433 // Throws error if key not found434 //435 // Selector: collectionProperty(string) cf24fd6d436 function collectionProperty(string memory key)437 public438 view439 returns (bytes memory)440 {441 require(false, stub_error);442 key;443 dummy;444 return hex"";445 }446447 // Selector: setCollectionSponsor(address) 7623402e448 function setCollectionSponsor(address sponsor) public {449 require(false, stub_error);450 sponsor;451 dummy = 0;452 }453454 // Selector: confirmCollectionSponsorship() 3c50e97a455 function confirmCollectionSponsorship() public {456 require(false, stub_error);457 dummy = 0;458 }459460 // Selector: setCollectionLimit(string,uint32) 6a3841db461 function setCollectionLimit(string memory limit, uint32 value) public {462 require(false, stub_error);463 limit;464 value;465 dummy = 0;466 }467468 // Selector: setCollectionLimit(string,bool) 993b7fba469 function setCollectionLimit(string memory limit, bool value) public {470 require(false, stub_error);471 limit;472 value;473 dummy = 0;474 }475476 // Selector: contractAddress() f6b4dfb4477 function contractAddress() public view returns (address) {478 require(false, stub_error);479 dummy;480 return 0x0000000000000000000000000000000000000000;481 }482483 // Selector: addCollectionAdminSubstrate(uint256) 5730062b484 function addCollectionAdminSubstrate(uint256 newAdmin) public view {485 require(false, stub_error);486 newAdmin;487 dummy;488 }489490 // Selector: removeCollectionAdminSubstrate(uint256) 4048fcf9491 function removeCollectionAdminSubstrate(uint256 newAdmin) public view {492 require(false, stub_error);493 newAdmin;494 dummy;495 }496497 // Selector: addCollectionAdmin(address) 92e462c7498 function addCollectionAdmin(address newAdmin) public view {499 require(false, stub_error);500 newAdmin;501 dummy;502 }503504 // Selector: removeCollectionAdmin(address) fafd7b42505 function removeCollectionAdmin(address admin) public view {506 require(false, stub_error);507 admin;508 dummy;509 }510511 // Selector: setCollectionNesting(bool) 112d4586512 function setCollectionNesting(bool enable) public {513 require(false, stub_error);514 enable;515 dummy = 0;516 }517518 // Selector: setCollectionNesting(bool,address[]) 64872396519 function setCollectionNesting(bool enable, address[] memory collections)520 public521 {522 require(false, stub_error);523 enable;524 collections;525 dummy = 0;526 }527528 // Selector: setCollectionAccess(uint8) 41835d4c529 function setCollectionAccess(uint8 mode) public {530 require(false, stub_error);531 mode;532 dummy = 0;533 }534535 // Selector: addToCollectionAllowList(address) 67844fe6536 function addToCollectionAllowList(address user) public view {537 require(false, stub_error);538 user;539 dummy;540 }541542 // Selector: removeFromCollectionAllowList(address) 85c51acb543 function removeFromCollectionAllowList(address user) public view {544 require(false, stub_error);545 user;546 dummy;547 }548549 // Selector: setCollectionMintMode(bool) 00018e84550 function setCollectionMintMode(bool mode) public {551 require(false, stub_error);552 mode;553 dummy = 0;554 }555}556557// Selector: d74d154f558contract ERC721UniqueExtensions is Dummy, ERC165 {559 // @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE560 // TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE561 // THEY MAY BE PERMANENTLY LOST562 // @dev Throws unless `msg.sender` is the current owner. Throws if `to`563 // is the zero address. Throws if `tokenId` is not a valid NFT.564 // @param to The new owner565 // @param tokenId The NFT to transfer566 // @param _value Not used for an NFT567 //568 // Selector: transfer(address,uint256) a9059cbb569 function transfer(address to, uint256 tokenId) public {570 require(false, stub_error);571 to;572 tokenId;573 dummy = 0;574 }575576 // @notice Burns a specific ERC721 token.577 // @dev Throws unless `msg.sender` is the current owner or an authorized578 // operator for this NFT. Throws if `from` is not the current owner. Throws579 // if `to` is the zero address. Throws if `tokenId` is not a valid NFT.580 // @param from The current owner of the NFT581 // @param tokenId The NFT to transfer582 // @param _value Not used for an NFT583 //584 // Selector: burnFrom(address,uint256) 79cc6790585 function burnFrom(address from, uint256 tokenId) public {586 require(false, stub_error);587 from;588 tokenId;589 dummy = 0;590 }591592 // @notice Returns next free NFT ID.593 //594 // Selector: nextTokenId() 75794a3c595 function nextTokenId() public view returns (uint256) {596 require(false, stub_error);597 dummy;598 return 0;599 }600601 // @notice Function to mint multiple tokens.602 // @dev `tokenIds` should be an array of consecutive numbers and first number603 // should be obtained with `nextTokenId` method604 // @param to The new owner605 // @param tokenIds IDs of the minted NFTs606 //607 // Selector: mintBulk(address,uint256[]) 44a9945e608 function mintBulk(address to, uint256[] memory tokenIds)609 public610 returns (bool)611 {612 require(false, stub_error);613 to;614 tokenIds;615 dummy = 0;616 return false;617 }618619 // @notice Function to mint multiple tokens with the given tokenUris.620 // @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive621 // numbers and first number should be obtained with `nextTokenId` method622 // @param to The new owner623 // @param tokens array of pairs of token ID and token URI for minted tokens624 //625 // Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006626 function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)627 public628 returns (bool)629 {630 require(false, stub_error);631 to;632 tokens;633 dummy = 0;634 return false;635 }636}637638contract UniqueNFT is639 Dummy,640 ERC165,641 ERC721,642 ERC721Metadata,643 ERC721Enumerable,644 ERC721UniqueExtensions,645 ERC721Mintable,646 ERC721Burnable,647 Collection,648 TokenProperties649{}