light_batched_merkle_tree/
errors.rs

1use light_account_checks::error::AccountError;
2use light_bloom_filter::BloomFilterError;
3use light_compressed_account::CompressedAccountError;
4use light_hasher::HasherError;
5use light_merkle_tree_metadata::errors::MerkleTreeMetadataError;
6use light_verifier::VerifierError;
7use light_zero_copy::errors::ZeroCopyError;
8use thiserror::Error;
9
10#[derive(Debug, Error, PartialEq)]
11pub enum BatchedMerkleTreeError {
12    #[error("Batch is not ready to be inserted")]
13    BatchNotReady,
14    #[error("Batch is already inserted")]
15    BatchAlreadyInserted,
16    #[error("Batch insert failed")]
17    BatchInsertFailed,
18    #[error("Leaf index not in batch.")]
19    LeafIndexNotInBatch,
20    #[error("Invalid network fee.")]
21    InvalidNetworkFee,
22    #[error("Batch size not divisible by ZKP batch size.")]
23    BatchSizeNotDivisibleByZkpBatchSize,
24    #[error("Inclusion proof by index failed.")]
25    InclusionProofByIndexFailed,
26    #[error("Hasher error: {0}")]
27    Hasher(#[from] HasherError),
28    #[error("Compressed Account error {0}")]
29    CompressedAccountError(#[from] CompressedAccountError),
30    #[error("Zero copy error {0}")]
31    ZeroCopy(#[from] ZeroCopyError),
32    #[error("Merkle tree metadata error {0}")]
33    MerkleTreeMetadata(#[from] MerkleTreeMetadataError),
34    #[error("Bloom filter error {0}")]
35    BloomFilter(#[from] BloomFilterError),
36    #[cfg(feature = "pinocchio")]
37    #[error("Program error {0}")]
38    ProgramError(u64),
39    #[cfg(not(feature = "pinocchio"))]
40    #[error("Program error {0}")]
41    ProgramError(#[from] solana_program_error::ProgramError),
42    #[error("Verifier error {0}")]
43    VerifierErrorError(#[from] VerifierError),
44    #[error("Invalid batch index")]
45    InvalidBatchIndex,
46    #[error("Invalid index")]
47    InvalidIndex,
48    #[error("Batched Merkle tree is full.")]
49    TreeIsFull,
50    #[error("Value already exists in bloom filter.")]
51    NonInclusionCheckFailed,
52    #[error("Bloom filter must be zeroed prior to reusing a batch.")]
53    BloomFilterNotZeroed,
54    #[error("Account error {0}")]
55    AccountError(#[from] AccountError),
56}
57
58impl From<BatchedMerkleTreeError> for u32 {
59    fn from(e: BatchedMerkleTreeError) -> u32 {
60        match e {
61            BatchedMerkleTreeError::BatchNotReady => 14301,
62            BatchedMerkleTreeError::BatchAlreadyInserted => 14302,
63            BatchedMerkleTreeError::BatchInsertFailed => 14303,
64            BatchedMerkleTreeError::LeafIndexNotInBatch => 14304,
65            BatchedMerkleTreeError::InvalidNetworkFee => 14305,
66            BatchedMerkleTreeError::BatchSizeNotDivisibleByZkpBatchSize => 14306,
67            BatchedMerkleTreeError::InclusionProofByIndexFailed => 14307,
68            BatchedMerkleTreeError::InvalidBatchIndex => 14308,
69            BatchedMerkleTreeError::InvalidIndex => 14309,
70            BatchedMerkleTreeError::TreeIsFull => 14310,
71            BatchedMerkleTreeError::NonInclusionCheckFailed => 14311,
72            BatchedMerkleTreeError::BloomFilterNotZeroed => 14312,
73            BatchedMerkleTreeError::Hasher(e) => e.into(),
74            BatchedMerkleTreeError::ZeroCopy(e) => e.into(),
75            BatchedMerkleTreeError::MerkleTreeMetadata(e) => e.into(),
76            BatchedMerkleTreeError::BloomFilter(e) => e.into(),
77            BatchedMerkleTreeError::VerifierErrorError(e) => e.into(),
78            BatchedMerkleTreeError::CompressedAccountError(e) => e.into(),
79            #[allow(clippy::useless_conversion)]
80            BatchedMerkleTreeError::ProgramError(e) => u32::try_from(u64::from(e)).unwrap(),
81            BatchedMerkleTreeError::AccountError(e) => e.into(),
82        }
83    }
84}
85
86#[cfg(feature = "solana")]
87impl From<BatchedMerkleTreeError> for solana_program_error::ProgramError {
88    fn from(e: BatchedMerkleTreeError) -> Self {
89        solana_program_error::ProgramError::Custom(e.into())
90    }
91}
92
93#[cfg(feature = "pinocchio")]
94impl From<BatchedMerkleTreeError> for pinocchio::program_error::ProgramError {
95    fn from(e: BatchedMerkleTreeError) -> Self {
96        pinocchio::program_error::ProgramError::Custom(e.into())
97    }
98}
99
100#[cfg(feature = "pinocchio")]
101impl From<pinocchio::program_error::ProgramError> for BatchedMerkleTreeError {
102    fn from(error: pinocchio::program_error::ProgramError) -> Self {
103        BatchedMerkleTreeError::ProgramError(u64::from(error))
104    }
105}