Upgradable Manifold ERC1155

This function is an initializer for a contract. It sets the name and symbol of the contract, and calls two other functions, __ERC1155_init and __Ownable_init. These two functions are likely responsible for setting up the contract's ERC1155 and Ownable features, respectively. (autogenerated documentation)

This function is used to check if a given interface is supported by the contract. It does this by checking if the interfaceId is supported by the ERC1155CreatorCore, ERC1155Upgradeable, and AdminControlUpgradeable contracts. If any of these contracts support the interfaceId, the function will return true. (autogenerated documentation)

This function is an override of the _beforeTokenTransfer function in the ERC-20 token standard. It is used to approve a transfer of tokens from one address to another. It takes in the addresses of the sender and receiver, an array of token IDs, an array of token amounts, and a byte array of data. It then calls the _approveTransfer function, passing in the sender and receiver addresses, the token IDs and amounts, to approve the transfer. (autogenerated documentation)

This function registers an extension with the contract. It requires the address of the extension, as well as a baseURI string. It is only accessible to the admin of the contract, and the extension address must not be blacklisted. The function sets the extension address and baseURI in the contract storage, and sets a boolean flag to indicate that the extension is registered. (autogenerated documentation)

This function allows an admin to register an extension contract with the base contract. It takes in the address of the extension contract, a base URI, and a boolean value indicating whether the base URI is identical to the one already stored in the base contract. If the base URI is identical, the function will register the extension contract and store the base URI in the base contract. If the base URI is not identical, the function will revert. This function also requires that the extension contract is not blacklisted and that the caller is an admin. (autogenerated documentation)

This function allows an admin to unregister an extension from the contract. It takes an address of the extension as an argument and removes it from the list of registered extensions. This function is only accessible to admins and requires them to have the adminRequired permission. (autogenerated documentation)

This function allows an admin to blacklist an extension address. This means that the extension address will no longer be able to interact with the contract. The function works by taking in an address as an argument and then calling the internal _blacklistExtension() function, which updates the blacklist mapping to include the extension address. (autogenerated documentation)

This function sets the base token URI extension for the contract. It takes a string as an argument and stores it in the contract's storage. This allows the contract to provide additional information about the token, such as its purpose, origin, or other relevant details. This information can then be accessed by anyone who interacts with the contract. (autogenerated documentation)

This function sets the base token URI extension for the contract. It takes two parameters: a string calldata uri_, which is the URI to be set, and a boolean identical, which indicates whether the URI should be identical to the base token URI. If identical is set to true, the URI will be set to the same as the base token URI. If it is set to false, the URI will be set to the value of uri_. The function is an external override extension, meaning that it can only be called by an external account with the required permission. (autogenerated documentation)

This function allows the contract owner to set a prefix for the token URI of the tokens issued by the contract. The prefix is a string of characters that will be added to the beginning of the token URI for each token. This allows the contract owner to easily identify the tokens issued by the contract and to provide additional information about the tokens. (autogenerated documentation)

This function sets the URI extension for a given token ID. It takes in a token ID and a URI string as parameters, and then calls the _setTokenURIExtension() function to set the URI extension for the given token ID. This allows the token to be associated with a specific URI, which can be used to provide additional information about the token. (autogenerated documentation)

This function is an override extension of the setTokenURIExtension function. It takes in two parameters, an array of uint256 tokenIds and an array of strings representing URIs. It then iterates through the arrays, setting the tokenURI for each tokenId to the corresponding URI. This ensures that the tokenURI for each tokenId is set correctly. (autogenerated documentation)

This function allows an admin to set the base token URI for the contract. The base token URI is a string that is used to identify the token and provide additional information about it. The function takes a string as an argument and sets it as the base token URI. This function is only accessible to admins and requires them to have the adminRequired permission. (autogenerated documentation)

This function allows an admin to set the token URI prefix for the contract. The token URI prefix is a string that is used to identify the token and provide additional information about it. The prefix is used to construct the full token URI, which is then used to access the token's metadata. The function takes a string as an argument and sets the token URI prefix to that string. (autogenerated documentation)

This function allows an admin to set the URI of a token with a given tokenId. The function takes two parameters, the tokenId and the uri_, which is a string containing the URI. The function then calls the _setTokenURI() function, which sets the URI of the token with the given tokenId. (autogenerated documentation)

This function allows an admin to set the token URI for multiple tokens at once. It takes two parameters, an array of token IDs and an array of URIs. It then iterates through the arrays, setting the token URI for each token ID to the corresponding URI. (autogenerated documentation)

This function sets the minting permissions for a given address (extension) to a given address (permissions). It is an external function that requires admin privileges to execute. It works by calling the internal _setMintPermissions() function, which updates the minting permissions for the given address. (autogenerated documentation)

This function is used to mint new tokens to a specified list of addresses. It takes in three parameters: an array of addresses to mint the tokens to, an array of amounts to mint to each address, and an array of strings containing URIs associated with the tokens. It returns an array of uint256 values representing the token IDs of the newly minted tokens. The function is protected by the adminRequired modifier, which ensures that only the admin can call the function. (autogenerated documentation)

This function is used to mint existing tokens to a specified address. It takes in an array of addresses, an array of token IDs, and an array of amounts as parameters. It first checks that the token IDs are valid and that the tokens have not been created by an extension. It then calls the _mintExisting function, passing in the address of the sender (0) and the other parameters. This function will mint the specified amount of tokens to the specified address. (autogenerated documentation)

This function is an extension of the mint function, allowing the sender to mint multiple tokens at once. It takes in an array of addresses, an array of amounts, and an array of URIs as parameters. It then calls the _mintNew function, passing in the sender's address, the array of addresses, the array of amounts, and the array of URIs as arguments. The _mintNew function then mints the specified tokens and returns an array of token IDs for the newly minted tokens. (autogenerated documentation)

This function is an override of the _mintExisting() function in the ERC721 contract. It is used to mint existing tokens to a specified address. It takes in three parameters: an array of addresses to mint the tokens to, an array of token IDs, and an array of amounts. It first checks that the tokens being minted were created by the extension, then calls the _mintExisting() function to mint the tokens. (autogenerated documentation)

This function is used to mint new tokens. It takes in an address of an extension, an array of addresses to send the tokens to, an array of amounts to send to each address, and an array of URIs associated with each token. It then checks the minting permissions, and mints the tokens either one at a time or in a batch. Finally, it sets the URIs for each token. (autogenerated documentation)

This function is used to mint existing tokens. It takes in four parameters: an address extension, an array of addresses to, an array of tokenIds, and an array of amounts. It checks the mint permissions for the given inputs, and then mints the tokens accordingly. If there is only one address, tokenId, and amount, it will mint a single token. If there is only one tokenId and multiple addresses and amounts, it will mint multiple tokens with the same tokenId but different amounts to each address. If there is only one address and multiple tokenIds and amounts, it will mint multiple tokens with the same address but different tokenIds and amounts. If there are multiple addresses, tokenIds, and (autogenerated documentation)

This function is used to retrieve the address of the token extension associated with a given token ID. It works by calling the _tokenExtension() internal function, which takes the token ID as an argument and returns the address of the associated token extension. (autogenerated documentation)

This function allows the owner of an account or an approved user to burn a given amount of tokens. It takes two arrays as input, one containing the token IDs and the other containing the amounts to be burned. If only one token is to be burned, the function calls the _burn() function, otherwise it calls the _burnBatch() function. Finally, it calls the _postBurn() function to update the state of the contract. (autogenerated documentation)

This function allows an admin to set royalties for a given set of receivers. It takes two parameters: an array of addresses of the receivers and an array of basis points for each receiver. The basis points represent the percentage of the total royalties that each receiver will receive. The function calls the _setRoyaltiesExtension() function, passing in a zero address and the two arrays of parameters. (autogenerated documentation)

This function allows an admin to set royalties for a given tokenId. It takes in two parameters: an array of addresses (receivers) and an array of uint256 (basisPoints). The function then calls the _setRoyalties() function, which sets the royalties for the given tokenId, assigning each address in the receivers array a corresponding basisPoint from the basisPoints array. (autogenerated documentation)

This function sets a royalties extension contract for the current contract. It requires an address of the extension contract, an array of payable addresses of the receivers, and an array of basis points for each receiver. The function will then call the _setRoyaltiesExtension() internal function to set the royalties extension contract, receivers, and basis points. (autogenerated documentation)

This function is used to retrieve the royalties associated with a given token ID. It works by calling the _getRoyalties() internal function, which returns an array of addresses and an array of uint256 values representing the royalties associated with the token ID. (autogenerated documentation)

This function gets the fees associated with a given token ID. It works by calling the _getRoyalties() internal function, which returns an array of addresses and an array of uint256 values representing the fees associated with the token ID. (autogenerated documentation)

This function is used to retrieve the addresses of the recipients of fees associated with a given token ID. It works by calling the _getRoyaltyReceivers() internal function, which returns an array of addresses payable that represent the fee recipients. (autogenerated documentation)

This function is used to retrieve the royalty fee (in basis points) associated with a given token ID. It works by calling the _getRoyaltyBPS() internal function, which returns an array of uints representing the royalty fee for the given token ID. (autogenerated documentation)

This function is used to retrieve royalty information for a given token ID and value. It takes two parameters, a token ID and a value, and returns an address and a uint256 value. The address is the address of the royalty recipient, and the uint256 value is the amount of royalty that will be paid to the recipient. The function works by calling the _getRoyaltyInfo() internal function, which is responsible for retrieving the royalty information from the contract's storage. (autogenerated documentation)

This function is used to retrieve the URI associated with a given token ID. It works by calling the _tokenURI() function, which is a virtual override of the ERC721 interface, and passing in the token ID as an argument. The function then returns the URI associated with the token ID as a string. (autogenerated documentation)

This function returns the total supply of a given tokenId. It works by accessing the _totalSupply mapping, which stores the total supply of each tokenId, and returning the value associated with the given tokenId. (autogenerated documentation)

This function is an override of the _mint() function from the ERC-20 standard. It is used to mint a new token with a given ID, amount, and data. The function adds the given amount to the total supply of the token with the given ID, and then calls the super._mint() function to mint the token. (autogenerated documentation)

This function is an override of the _mintBatch() function from the ERC-1155 contract. It is used to mint multiple tokens at once. It takes in an address to mint the tokens to, an array of ids for the tokens to be minted, an array of amounts for the tokens to be minted, and a data field. It then calls the super function to mint the tokens, and then updates the total supply of each token by adding the amount of each token to the total supply. (autogenerated documentation)

This function is an override of the _burn() function from the ERC-20 standard. It reduces the total supply of a token by the specified amount. It takes three parameters: the address of the account burning the token, the ID of the token being burned, and the amount of the token being burned. The function first calls the _burn() function from the ERC-20 standard, and then reduces the total supply of the token by the specified amount. (autogenerated documentation)

This function is an override of the _burnBatch() function from the ERC20 contract. It is used to burn a batch of tokens from a given account. It takes in an address (account), an array of ids (ids) and an array of amounts (amounts) as parameters. It then iterates through the ids array and subtracts the corresponding amount from the total supply of the token. (autogenerated documentation)