# Errors

Library for all Aria contract custom errors.

## Errors

### AriaIPRWAVault\_\_ZeroAmount

Thrown when the amount is zero

```solidity
error AriaIPRWAVault__ZeroAmount();
```

### AriaIPRWAVault\_\_ZeroRoyaltyTokenDistributionWorkflowsAddress

Thrown when the royalty token distribution workflows address is zero

```solidity
error AriaIPRWAVault__ZeroRoyaltyTokenDistributionWorkflowsAddress();
```

### AriaIPRWAVault\_\_ZeroRoyaltyModuleAddress

Thrown when the royalty module address is zero

```solidity
error AriaIPRWAVault__ZeroRoyaltyModuleAddress();
```

### AriaIPRWAVault\_\_ZeroTokenizerModuleAddress

Thrown when the tokenizer module address is zero

```solidity
error AriaIPRWAVault__ZeroTokenizerModuleAddress();
```

### AriaIPRWAVault\_\_ZeroFractionalTokenTemplateAddress

Thrown when the fractional token template address is zero

```solidity
error AriaIPRWAVault__ZeroFractionalTokenTemplateAddress();
```

### AriaIPRWAVault\_\_ZeroAdminAddress

Thrown when the admin address is zero

```solidity
error AriaIPRWAVault__ZeroAdminAddress();
```

### AriaIPRWAVault\_\_ExpirationTimeNotInFuture

Thrown when the expiration time is not in the future

```solidity
error AriaIPRWAVault__ExpirationTimeNotInFuture(uint256 expirationTime, uint256 currentTime);
```

**Parameters**

| Name             | Type      | Description                  |
| ---------------- | --------- | ---------------------------- |
| `expirationTime` | `uint256` | The provided expiration time |
| `currentTime`    | `uint256` | The current time             |

### AriaIPRWAVault\_\_ZeroFundReceiverAddress

Thrown when the fund receiver address is zero

```solidity
error AriaIPRWAVault__ZeroFundReceiverAddress();
```

### AriaIPRWAVault\_\_ZeroUsdcContractAddress

Thrown when the USDC contract address is zero

```solidity
error AriaIPRWAVault__ZeroUsdcContractAddress();
```

### AriaIPRWAVault\_\_ZeroSPGNftContractAddress

Thrown when the spg nft contract address is zero

```solidity
error AriaIPRWAVault__ZeroSPGNftContractAddress();
```

### AriaIPRWAVault\_\_FractionalTokenNotSet

Thrown when the fractional token is not set

```solidity
error AriaIPRWAVault__FractionalTokenNotSet();
```

### AriaIPRWAVault\_\_CallerNotAdmin

Thrown when the caller is not the admin

```solidity
error AriaIPRWAVault__CallerNotAdmin(address caller, address admin);
```

**Parameters**

| Name     | Type      | Description                 |
| -------- | --------- | --------------------------- |
| `caller` | `address` | The function caller address |
| `admin`  | `address` | The admin address           |

### AriaIPRWAVault\_\_InvalidUSDCAddress

Thrown when the USDC address is invalid

```solidity
error AriaIPRWAVault__InvalidUSDCAddress();
```

### AriaIPRWAVault\_\_UnsupportedIERC20

Thrown when the token is not supported

```solidity
error AriaIPRWAVault__UnsupportedIERC20();
```

### AriaIPRWAVault\_\_VaultNotOpen

Thrown when the vault is not open

```solidity
error AriaIPRWAVault__VaultNotOpen(FundraiseState currentState);
```

**Parameters**

| Name           | Type             | Description                    |
| -------------- | ---------------- | ------------------------------ |
| `currentState` | `FundraiseState` | The current state of the vault |

### AriaIPRWAVault\_\_VaultNotCanceled

Thrown when the vault is not canceled

```solidity
error AriaIPRWAVault__VaultNotCanceled(FundraiseState currentState);
```

**Parameters**

| Name           | Type             | Description                    |
| -------------- | ---------------- | ------------------------------ |
| `currentState` | `FundraiseState` | The current state of the vault |

### AriaIPRWAVault\_\_NoRefundableDeposit

Thrown when there is no refundable deposit

```solidity
error AriaIPRWAVault__NoRefundableDeposit(address claimer, address token);
```

**Parameters**

| Name      | Type      | Description                                              |
| --------- | --------- | -------------------------------------------------------- |
| `claimer` | `address` | The address of the claimer                               |
| `token`   | `address` | The address of the token that the claimer wants to claim |

### AriaIPRWAVault\_\_VaultNotClosed

Thrown when the vault is not closed

```solidity
error AriaIPRWAVault__VaultNotClosed(FundraiseState currentState);
```

**Parameters**

| Name           | Type             | Description                    |
| -------------- | ---------------- | ------------------------------ |
| `currentState` | `FundraiseState` | The current state of the vault |

### AriaIPRWAVault\_\_ZeroDepositAmount

Thrown when the deposit amount is zero

```solidity
error AriaIPRWAVault__ZeroDepositAmount(address depositor, address token);
```

**Parameters**

| Name        | Type      | Description                                                  |
| ----------- | --------- | ------------------------------------------------------------ |
| `depositor` | `address` | The address of the depositor                                 |
| `token`     | `address` | The address of the token that the depositor wants to deposit |

### AriaIPRWAVault\_\_ClaimerNotEligible

Thrown when the claimer is not eligible to claim the fractionalized IP tokens

```solidity
error AriaIPRWAVault__ClaimerNotEligible(address claimer, address usdc);
```

**Parameters**

| Name      | Type      | Description                                         |
| --------- | --------- | --------------------------------------------------- |
| `claimer` | `address` | The address of the claimer                          |
| `usdc`    | `address` | The USDC address used to deposit into the fundraise |

### AriaIPRWAVault\_\_ClaimerAlreadyClaimed

Thrown when the claimer has already claimed the fractionalized IP tokens

```solidity
error AriaIPRWAVault__ClaimerAlreadyClaimed(address claimer);
```

**Parameters**

| Name      | Type      | Description                |
| --------- | --------- | -------------------------- |
| `claimer` | `address` | The address of the claimer |

### AriaIPRWAVault\_\_WhitelistDisabled

Thrown when the whitelist is disabled

```solidity
error AriaIPRWAVault__WhitelistDisabled();
```

### AriaIPRWAVault\_\_WhitelistProofInvalid

Thrown when the whitelist merkle proof is invalid

```solidity
error AriaIPRWAVault__WhitelistProofInvalid();
```

### AriaIPRWAVault\_\_CallerNotWhitelisted

Thrown when the caller is not whitelisted

```solidity
error AriaIPRWAVault__CallerNotWhitelisted();
```

### AriaIPRWAVault\_\_ActiveDepositsExist

Thrown when there are active deposits

```solidity
error AriaIPRWAVault__ActiveDepositsExist(address token, uint256 totalDeposits);
```

**Parameters**

| Name            | Type      | Description              |
| --------------- | --------- | ------------------------ |
| `token`         | `address` | The address of the token |
| `totalDeposits` | `uint256` | The total deposits       |

### AriaIPRWAVault\_\_FractionalTokenSupplyLessThanTotalDeposits

Thrown when the fractional token total supply is less than the total deposits

```solidity
error AriaIPRWAVault__FractionalTokenSupplyLessThanTotalDeposits(
    uint256 fractionalTokenTotalSupply, uint256 totalDeposits
);
```

**Parameters**

| Name                         | Type      | Description                              |
| ---------------------------- | --------- | ---------------------------------------- |
| `fractionalTokenTotalSupply` | `uint256` | The total supply of the fractional token |
| `totalDeposits`              | `uint256` | The total deposits                       |

### AriaIPRWAVault\_\_FractionalTokenAlreadyDeployed

Thrown when the fractional token is already deployed

```solidity
error AriaIPRWAVault__FractionalTokenAlreadyDeployed(address fractionalToken);
```

**Parameters**

| Name              | Type      | Description                         |
| ----------------- | --------- | ----------------------------------- |
| `fractionalToken` | `address` | The address of the fractional token |

### AriaIPRWAVault\_\_NoRaise

Thrown when there is no raise has been made.\`\`

```solidity
error AriaIPRWAVault__NoRaise();
```

### AriaIPRWAVault\_\_NothingToRecover

Thrown when there is nothing to recover

```solidity
error AriaIPRWAVault__NothingToRecover();
```

### AriaIPRWAVault\_\_ZeroMintTimelockDuration

Thrown when trying to set a mint timelock duration of zero

```solidity
error AriaIPRWAVault__ZeroMintTimelockDuration();
```

### AriaIPRWAVault\_\_ZeroMintAmount

Thrown when the mint amount is zero during initiation.

```solidity
error AriaIPRWAVault__ZeroMintAmount();
```

### AriaIPRWAVault\_\_MintAlreadyPending

Thrown when initiating a mint while another is already pending.

```solidity
error AriaIPRWAVault__MintAlreadyPending();
```

### AriaIPRWAVault\_\_TimelockCalculationOverflow

Thrown if calculating the unlock timestamp results in an overflow.

```solidity
error AriaIPRWAVault__TimelockCalculationOverflow();
```

### AriaIPRWAVault\_\_NoPendingExecution

Thrown when attempting to execute a timelocked action when none is pending.

```solidity
error AriaIPRWAVault__NoPendingExecution();
```

### AriaIPRWAVault\_\_TimelockNotReached

Thrown when attempting to execute a timelocked action before the timelock is reached.

```solidity
error AriaIPRWAVault__TimelockNotReached(uint48 unlockTimestamp);
```

**Parameters**

| Name              | Type     | Description                              |
| ----------------- | -------- | ---------------------------------------- |
| `unlockTimestamp` | `uint48` | The timestamp when the timelock expires. |

### AriaIPRWAVault\_\_DurationUpdateAlreadyPending

Thrown when attempting to initiate a duration update while another is pending.

```solidity
error AriaIPRWAVault__DurationUpdateAlreadyPending();
```

### AriaIPRWAVault\_\_CannotSetZeroTimelockDuration

Thrown when attempting to set the withdrawal timelock duration to zero.

```solidity
error AriaIPRWAVault__CannotSetZeroTimelockDuration();
```

### AriaIPRWAVault\_\_FractionalTokenCapExceeded

Thrown when the fractional token cap is exceeded on upcoming claim

```solidity
error AriaIPRWAVault__FractionalTokenCapExceeded();
```

### AriaIPRWAVault\_\_InvalidClaimDeadline

Thrown when the claim deadline is invalid

```solidity
error AriaIPRWAVault__InvalidClaimDeadline();
```

### AriaIPRWAVaultFactory\_\_CallerNotAdmin

Thrown when the caller is not the factory admin

```solidity
error AriaIPRWAVaultFactory__CallerNotAdmin(address caller, address admin);
```

**Parameters**

| Name     | Type      | Description                 |
| -------- | --------- | --------------------------- |
| `caller` | `address` | The function caller address |
| `admin`  | `address` | The admin address           |

### AriaIPRWAVaultFactory\_\_ZeroAdminAddress

Thrown when the admin address is zero

```solidity
error AriaIPRWAVaultFactory__ZeroAdminAddress();
```

### AriaIPRWAVaultFactory\_\_ZeroVaultTemplateAddress

Thrown when the vault template address is zero

```solidity
error AriaIPRWAVaultFactory__ZeroVaultTemplateAddress();
```

### AriaIPDistributionContract\_\_CallerNotAdmin

Thrown when the caller is not the admin

```solidity
error AriaIPDistributionContract__CallerNotAdmin(address caller, address admin);
```

**Parameters**

| Name     | Type      | Description                 |
| -------- | --------- | --------------------------- |
| `caller` | `address` | The function caller address |
| `admin`  | `address` | The admin address           |

### AriaIPDistributionContract\_\_ZeroRoyaltyModuleAddress

Thrown when the royalty module address is zero

```solidity
error AriaIPDistributionContract__ZeroRoyaltyModuleAddress();
```

### AriaIPDistributionContract\_\_ZeroUpgradeableBeaconAddress

Thrown when the upgradeable beacon address is zero

```solidity
error AriaIPDistributionContract__ZeroUpgradeableBeaconAddress();
```

### AriaIPDistributionContract\_\_ZeroFractionalTokenAddress

Thrown when the fractional token address is zero

```solidity
error AriaIPDistributionContract__ZeroFractionalTokenAddress();
```

### AriaIPDistributionContract\_\_ZeroAdminAddress

Thrown when the admin address is zero

```solidity
error AriaIPDistributionContract__ZeroAdminAddress();
```

### AriaIPDistributionContract\_\_ZeroIpIdAddress

Thrown when the IP ID address is zero

```solidity
error AriaIPDistributionContract__ZeroIpIdAddress();
```

### AriaIPDistributionContract\_\_ZeroProtocolTreasuryAddress

Thrown when the protocol treasury address is zero

```solidity
error AriaIPDistributionContract__ZeroProtocolTreasuryAddress();
```

### AriaIPDistributionContract\_\_ZeroRewardTokenAddress

Thrown when the reward token address is zero

```solidity
error AriaIPDistributionContract__ZeroRewardTokenAddress();
```

### AriaIPDistributionContract\_\_ZeroFractionalTokenAllocPoints

Thrown when the fractional token alloc points is zero

```solidity
error AriaIPDistributionContract__ZeroFractionalTokenAllocPoints();
```

### AriaIPDistributionContract\_\_ZeroStakingTokenAddress

Thrown when the staking token address is zero

```solidity
error AriaIPDistributionContract__ZeroStakingTokenAddress();
```

### AriaIPDistributionContract\_\_ZeroDepositAmount

Thrown when the deposit amount is zero

```solidity
error AriaIPDistributionContract__ZeroDepositAmount();
```

### AriaIPDistributionContract\_\_ZeroWithdrawAmount

Thrown when the withdraw amount is zero

```solidity
error AriaIPDistributionContract__ZeroWithdrawAmount();
```

### AriaIPDistributionContract\_\_ZeroRewardDistributionPeriod

Thrown when the reward distribution period is zero

```solidity
error AriaIPDistributionContract__ZeroRewardDistributionPeriod();
```

### AriaIPDistributionContract\_\_StakingPoolAlreadyExists

Thrown when attempting to add a staking pool that already exists

```solidity
error AriaIPDistributionContract__StakingPoolAlreadyExists(address stakingToken);
```

**Parameters**

| Name           | Type      | Description                      |
| -------------- | --------- | -------------------------------- |
| `stakingToken` | `address` | The address of the staking token |

### AriaIPDistributionContract\_\_InsufficientStakedBalance

Thrown when the staker's staked balance is insufficient

```solidity
error AriaIPDistributionContract__InsufficientStakedBalance(
    address staker, address stakingToken, uint256 stakedBalance, uint256 withdrawAmount
);
```

**Parameters**

| Name             | Type      | Description                              |
| ---------------- | --------- | ---------------------------------------- |
| `staker`         | `address` | The address of the staker                |
| `stakingToken`   | `address` | The address of the staking token         |
| `stakedBalance`  | `uint256` | The staker's staked balance              |
| `withdrawAmount` | `uint256` | The amount of staking tokens to withdraw |

### AriaIPDistributionContract\_\_NoRewardsToClaim

Thrown when there are no rewards to claim

```solidity
error AriaIPDistributionContract__NoRewardsToClaim(address claimer);
```

**Parameters**

| Name      | Type      | Description                |
| --------- | --------- | -------------------------- |
| `claimer` | `address` | The address of the claimer |

### AriaIPDistributionContract\_\_IpRoyaltyVaultNotDeployed

Thrown when the IP royalty vault is not deployed

```solidity
error AriaIPDistributionContract__IpRoyaltyVaultNotDeployed(address ipId);
```

**Parameters**

| Name   | Type      | Description |
| ------ | --------- | ----------- |
| `ipId` | `address` | The IP ID   |
