> For the complete documentation index, see [llms.txt](https://docs.eesee.io/contracts/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.eesee.io/contracts/smart-contracts/contracts/nft/eeseenftdrop.md).

# EeseeNFTDrop

## EeseeNFTDrop

### baseURI

```solidity
string baseURI
```

*Base URI this contract uses while not revealed.*

### revealedURI

```solidity
string revealedURI
```

*Base URI this contract uses after reveal.*

### contractURI

```solidity
string contractURI
```

*Opensea royalty and NFT collection info.*

### mintLimit

```solidity
uint32 mintLimit
```

*Mint cap.*

### stages

```solidity
struct IEeseeNFTDrop.SaleStage[] stages
```

*Info about sale stages.*

### random

```solidity
contract IEeseeRandom random
```

*Contract that provides random.*

### minter

```solidity
address minter
```

*Minter contract.*

### initialize

```solidity
function initialize(struct DropMetadata metadata, uint32 _mintLimit, uint32 mintStartTimestamp, struct IEeseeNFTDrop.StageOptions[] salesOptions, contract IEeseeRandom _random, address _minter) external
```

### mint

```solidity
function mint(address recipient, uint32 quantity, bytes32[] merkleProof) external
```

*Mints nfts for recipient in the merkle tree.*

#### Parameters

| Name        | Type       | Description                       |
| ----------- | ---------- | --------------------------------- |
| recipient   | address    | - Address of recipient.           |
| quantity    | uint32     | - Amount of nfts to mint.         |
| merkleProof | bytes32\[] | - Merkle tree proof of recipient. |

Note: This function can only be called by minter. |

### nextTokenId

```solidity
function nextTokenId() external view returns (uint256)
```

*Returns next token ID to be minted.*

#### Return Values

| Name | Type    | Description       |
| ---- | ------- | ----------------- |
| \[0] | uint256 | uint256 Token ID. |

### tokenURI

```solidity
function tokenURI(uint256 tokenId) public view virtual returns (string)
```

*Returns tokenId's token URI. If there is no URI in tokenURIs uses baseURI.*

#### Parameters

| Name    | Type    | Description          |
| ------- | ------- | -------------------- |
| tokenId | uint256 | - Token ID to check. |

#### Return Values

| Name | Type   | Description       |
| ---- | ------ | ----------------- |
| \[0] | string | string Token URI. |

### verifyCanMint

```solidity
function verifyCanMint(uint8 saleStageIndex, address claimer, bytes32[] merkleProof) public view returns (bool)
```

*Verifies that a user is in allowlist of saleStageIndex sale stage.*

#### Parameters

| Name           | Type       | Description                            |
| -------------- | ---------- | -------------------------------------- |
| saleStageIndex | uint8      | - Index of the sale stage.             |
| claimer        | address    | - Address of a user.                   |
| merkleProof    | bytes32\[] | - Merkle proof of stage's merkle tree. |

#### Return Values

| Name | Type | Description                             |
| ---- | ---- | --------------------------------------- |
| \[0] | bool | bool true if user in stage's allowlist. |

### getSaleStage

```solidity
function getSaleStage() public view returns (uint8 index)
```

*Returns current sale stages index. Note: If all stages ended returns stages.length;*

#### Return Values

| Name  | Type  | Description                    |
| ----- | ----- | ------------------------------ |
| index | uint8 | - Index of current sale stage. |

### supportsInterface

```solidity
function supportsInterface(bytes4 interfaceId) public view returns (bool)
```

## Inherited from ERC2771Context

### isTrustedForwarder

```solidity
function isTrustedForwarder(address forwarder) public view virtual returns (bool)
```

## Inherited from ERC2981

### royaltyInfo

```solidity
function royaltyInfo(uint256 tokenId, uint256 salePrice) public view virtual returns (address, uint256)
```

*Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of exchange. The royalty amount is denominated and should be paid in that same unit of exchange.*

## Inherited from ERC721AUpgradeable

### totalSupply

```solidity
function totalSupply() public view virtual returns (uint256)
```

\_Returns the total number of tokens in existence. Burned tokens will reduce the count. To get the total number of tokens minted, please see {*totalMinted}.*

### balanceOf

```solidity
function balanceOf(address owner) public view virtual returns (uint256)
```

*Returns the number of tokens in `owner`'s account.*

### name

```solidity
function name() public view virtual returns (string)
```

*Returns the token collection name.*

### symbol

```solidity
function symbol() public view virtual returns (string)
```

*Returns the token collection symbol.*

### ownerOf

```solidity
function ownerOf(uint256 tokenId) public view virtual returns (address)
```

\_Returns the owner of the `tokenId` token.

Requirements:

* `tokenId` must exist.\_

### approve

```solidity
function approve(address to, uint256 tokenId) public payable virtual
```

\_Gives permission to `to` to transfer `tokenId` token to another account. See {ERC721A-\_approve}.

Requirements:

* The caller must own the token or be an approved operator.\_

### getApproved

```solidity
function getApproved(uint256 tokenId) public view virtual returns (address)
```

\_Returns the account approved for `tokenId` token.

Requirements:

* `tokenId` must exist.\_

### setApprovalForAll

```solidity
function setApprovalForAll(address operator, bool approved) public virtual
```

\_Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.

Requirements:

* The `operator` cannot be the caller.

Emits an {ApprovalForAll} event.\_

### isApprovedForAll

```solidity
function isApprovedForAll(address owner, address operator) public view virtual returns (bool)
```

\_Returns if the `operator` is allowed to manage all of the assets of `owner`.

See {setApprovalForAll}.\_

### transferFrom

```solidity
function transferFrom(address from, address to, uint256 tokenId) public payable virtual
```

\_Transfers `tokenId` from `from` to `to`.

Requirements:

* `from` cannot be the zero address.
* `to` cannot be the zero address.
* `tokenId` token must be owned by `from`.
* If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.

Emits a {Transfer} event.\_

### safeTransferFrom

```solidity
function safeTransferFrom(address from, address to, uint256 tokenId) public payable virtual
```

*Equivalent to `safeTransferFrom(from, to, tokenId, '')`.*

### safeTransferFrom

```solidity
function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) public payable virtual
```

\_Safely transfers `tokenId` token from `from` to `to`.

Requirements:

* `from` cannot be the zero address.
* `to` cannot be the zero address.
* `tokenId` token must exist and be owned by `from`.
* If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.

Emits a {Transfer} event.\_

## Inherited from IERC721AUpgradeable

### Transfer

```solidity
event Transfer(address from, address to, uint256 tokenId)
```

*Emitted when `tokenId` token is transferred from `from` to `to`.*

### Approval

```solidity
event Approval(address owner, address approved, uint256 tokenId)
```

*Emitted when `owner` enables `approved` to manage the `tokenId` token.*

### ApprovalForAll

```solidity
event ApprovalForAll(address owner, address operator, bool approved)
```

*Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.*

### ConsecutiveTransfer

```solidity
event ConsecutiveTransfer(uint256 fromTokenId, uint256 toTokenId, address from, address to)
```

\_Emitted when tokens in `fromTokenId` to `toTokenId` (inclusive) is transferred from `from` to `to`, as defined in the [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.

See {*mintERC2309} for more details.*

## Inherited from IEeseeNFTDrop

### baseURI

```solidity
function baseURI() external view returns (string)
```

### revealedURI

```solidity
function revealedURI() external view returns (string)
```

### contractURI

```solidity
function contractURI() external view returns (string)
```

### mintLimit

```solidity
function mintLimit() external view returns (uint32)
```

### random

```solidity
function random() external view returns (contract IEeseeRandom)
```

### stages

```solidity
function stages(uint256) external view returns (uint32 startTimestamp, struct IEeseeNFTDrop.StageOptions stageOptions)
```

## Inherited from Initializable

### Initialized

```solidity
event Initialized(uint8 version)
```

*Triggered when the contract has been initialized or reinitialized.*