# Core functions

### Router.sol

```solidity
// mint price to register a hash (excluding optional file verification)
uint public MINT_PRICE;

// ether price to verify a file URL
uint public VERIFICATION_PRICE;

/**
* @notice Generates the tProof for one (or more) given hashes. Each tProof will be in the form of an NFT
* @dev All the arrays must have same length and same order: all elements in pos-0 must refer to same hash, etc
* @param _hash list of hashes to verify
* @param _title list of titles for NFTs. If empty, a shorter version of the hash is used when generating TokenURI
* @param _withFileURL true if a public file upload will follow, false otherwise. Prepays the certification call
* @param _storageType id of the storage used to store the file. See docs for list. If _withFileUrl is false, this param is ignored (Set it ot 0)
* @param _to Who will receive the NFT(s)
* @param _delegateTo If we want to delegate another address to call for the verifyHashFileUrl call. Useful for better UX. Set to 0x for empty
*/
function createProofs(
                bytes32[] calldata _hash, 
                string[] calldata _title,
                bool[] calldata _withFileURL,
                uint16[] calldata _storageType, 
                address _to, address _delegateTo)
                    external payable

/**
* @notice Allows NFT owner to edit the title of a given NFT
* @dev You can pass an array of NFTs, with corresponding titles, to change more titles at the same time
* @param _nftNum IDs on NFTs to operate on
* @param _title list of titles to assign to NFTs
*/
function editProofTitle(
                uint[] calldata _nftNum, 
                string[] calldata _title) 
                     external
                     
     
/**
* @notice Uploads an URL and triggers the verification of hash connected to the given file
* @param _nft List of nft
* @param _url list of URLs to verify. See docs to understand the format of it, based on _storageType
* @param _storageType The type of storage for each given URL. Needed to verify they match the paid one
* @param _mimeType optional mime type for the given file. 0 to set undefined
*/
function verifyHashFileUrl(
                uint[] calldata _nft, 
                string[] calldata _url,
                uint16[] calldata _storageType, 
                uint32[] calldata _mimeType) 
                     external
                     
/**
* @notice Extend the verification period for an hash. Can be used also to verify an hash after a simple mint.
   If NFT is verified, this function sets it as not verified, thus the verification must re-run again.
* @param _nft List of nft
* @param _storageType The type of storage for each given NFT where it's plan to upload the file
*/
function extendVerification(
                uint[] calldata _nft, 
                uint16[] calldata _storageType) 
                     external payable                                         
```

### HashRegistry.sol

```solidity
/**
* @notice returns the url connected to a given hash
* @param _nft the nft to get the url stored
* @param _version the version of the URL to return. See docs based on storageType for the given file. 0 for the essential storage data, 1 for the fullUrl version. Other values may be possible
* @return a string representing the url, in the format required
**/
function getUrlFromNFT(
             uint _nft, 
             uint _version)
                 public view returns(string memory)
```

### NFTFactory.sol

```solidity
/**
* @notice Update the title of the NFT
* @dev Only owner of NFT can update the title of the NFT
* @param _nftNum id of NFT to update
* @param _title The new title (can also be empty)
**/
function updateTitle(
                uint[] calldata _nftNum, 
                string[] calldata _title) 
                      external
                         
/**
* @notice Set the optional description
* @dev Only owner of NFT can update the description of the NFT
* @param _nftNum list of NFT to set description
* @param _description List of description to associate
**/
function setDescription(
                uint[] calldata _nftNum, 
                string[] calldata _description) 
                      external
```

### **NFTTokenUriGenerator.sol** <a href="#blob-path" id="blob-path"></a>

```solidity
/**
 * @notice Generates the token URI
 * @param _tokenId the id of the NFT
 * @return a string representing the TokenUri
 **/
 function getTokenUri(
                uint256 _tokenId) 
                       external view returns (string memory) 
```

### **HashRegistryStorageType\_ArweaveV1.sol** <a href="#blob-path" id="blob-path"></a>

```solidity
/**
* @notice get the string representing the url
* @param _nft the nft connected to the url
* @param _version the version of the URL to return. See docs based on storageType for the given file. Generally 0 for the essential storage data, 1 for the fullUrl version. Other values may be possible
* @return a string representing the url, in the format required
**/
function getUrlString(
                uint _nft, 
                uint _version) 
                     external view returns (string memory)
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.tproof.io/technical-section/smart-contracts-overview/core-functions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.