test_output.log

cargo : warning: profiles for the non root package will be ignored, specify profiles at the 
workspace root:
At line:1 char:1
+ cargo test -p callora-cross-contract-tests 2> test_output.log
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (warning: profil...workspace root::String) [], RemoteEx 
   ception
    + FullyQualifiedErrorId : NativeCommandError
 
package:   C:\Users\USER\Desktop\Callora-Contracts\contracts\revenue_pool\fuzz\Cargo.toml
workspace: C:\Users\USER\Desktop\Callora-Contracts\Cargo.toml
warning: unused import: `StorageKey`
 --> contracts\settlement\src\batch.rs:1:49
  |
1 | use crate::{CalloraSettlement, SettlementError, StorageKey};
  |                                                 ^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default

warning: unused variable: `env`
    --> contracts\settlement\src\lib.rs:1124:9
     |
1124 |         env: Env,
     |         ^^^ help: if this is intentional, prefix it with an underscore: `_env`
     |
     = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default

warning: unused variable: `cursor`
    --> contracts\settlement\src\lib.rs:1127:9
     |
1127 |         cursor: u32,
     |         ^^^^^^ help: if this is intentional, prefix it with an underscore: `_cursor`

warning: unused variable: `limit`
    --> contracts\settlement\src\lib.rs:1128:9
     |
1128 |         limit: u32,
     |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_limit`

   Compiling callora-vault v0.0.1 (C:\Users\USER\Desktop\Callora-Contracts\contracts\vault)
warning: `callora-settlement` (lib) generated 4 warnings (run `cargo fix --lib -p 
callora-settlement` to apply 4 suggestions)
error[E0255]: the name `token` is defined multiple times
   --> contracts\vault\src\lib.rs:184:1
    |
 51 |     contract, contractclient, contractimpl, contracttype, token, Address, BytesN, Env, String,
    |                                                           ----- previous import of the module 
`token` here
...
184 | pub mod token {
    | ^^^^^^^^^^^^^ `token` redefined here
    |
    = note: `token` must be defined only once in the type namespace of this module
help: you can use `as` to change the binding name of the import
    |
 51 |     contract, contractclient, contractimpl, contracttype, token as other_token, Address, 
BytesN, Env, String,
    |                                                                 ++++++++++++++

error[E0255]: the name `VaultError` is defined multiple times
  --> contracts\vault\src\lib.rs:67:1
   |
58 | pub use errors::VaultError;
   |         ------------------ previous import of the type `VaultError` here
...
67 | pub enum VaultError {
   | ^^^^^^^^^^^^^^^^^^^ `VaultError` redefined here
   |
   = note: `VaultError` must be defined only once in the type namespace of this module
help: you can use `as` to change the binding name of the import
   |
58 | pub use errors::VaultError as OtherVaultError;
   |                            ++++++++++++++++++

error[E0432]: unresolved imports `crate::INSTANCE_BUMP_AMOUNT`, `crate::INSTANCE_BUMP_THRESHOLD`
  --> contracts\vault\src\limits.rs:17:37
   |
17 | use crate::{StorageKey, VaultError, INSTANCE_BUMP_AMOUNT, INSTANCE_BUMP_THRESHOLD};
   |                                     ^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^ no 
`INSTANCE_BUMP_THRESHOLD` in the root
   |                                     |
   |                                     no `INSTANCE_BUMP_AMOUNT` in the root

error: cannot find attribute `contracterror` in this scope
  --> contracts\vault\src\lib.rs:64:3
   |
64 | #[contracterror]
   |   ^^^^^^^^^^^^^

error[E0425]: cannot find function `event_reserve_cap_set` in module `events`
    --> contracts\vault\src\lib.rs:1110:22
     |
1110 |             (events::event_reserve_cap_set(&env), caller, token),
     |                      ^^^^^^^^^^^^^^^^^^^^^ not found in `events`

warning: unused imports: `String`, `contractclient`, and `token`
  --> contracts\vault\src\lib.rs:51:15
   |
51 |     contract, contractclient, contractimpl, contracttype, token, Address, BytesN, Env, String,
   |               ^^^^^^^^^^^^^^                              ^^^^^                        ^^^^^^
   |
   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default

warning: unused import: `StorageKey`
  --> contracts\vault\src\views.rs:24:65
   |
24 | use crate::{CalloraVault, CalloraVaultArgs, CalloraVaultClient, StorageKey, VaultError};
   |                                                                 ^^^^^^^^^^

warning: unnecessary parentheses around method argument
   --> contracts\vault\src\lib.rs:851:13
    |
851 |             (existing.is_some()),
    |             ^                  ^
    |
    = note: `#[warn(unused_parens)]` (part of `#[warn(unused)]`) on by default
help: remove these parentheses
    |
851 -             (existing.is_some()),
851 +             existing.is_some(),
    |

warning: unnecessary parentheses around method argument
   --> contracts\vault\src\lib.rs:936:13
    |
936 |             (existing.is_some()),
    |             ^                  ^
    |
help: remove these parentheses
    |
936 -             (existing.is_some()),
936 +             existing.is_some(),
    |

warning: unnecessary parentheses around method argument
    --> contracts\vault\src\lib.rs:1044:13
     |
1044 |             (existing.is_some()),
     |             ^                  ^
     |
help: remove these parentheses
     |
1044 -             (existing.is_some()),
1044 +             existing.is_some(),
     |

error[E0119]: conflicting implementations of trait `Clone` for type `errors::VaultError`
  --> contracts\vault\src\lib.rs:66:16
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                ^^^^^ conflicting implementation for `errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:50:16
   |
50 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                ----- first implementation here

error[E0119]: conflicting implementations of trait `Debug` for type `errors::VaultError`
  --> contracts\vault\src\lib.rs:66:23
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                       ^^^^^ conflicting implementation for `errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:50:23
   |
50 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                       ----- first implementation here

error[E0119]: conflicting implementations of trait `Eq` for type `errors::VaultError`
  --> contracts\vault\src\lib.rs:66:30
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                              ^^ conflicting implementation for `errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:50:30
   |
50 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                              -- first implementation here

error[E0119]: conflicting implementations of trait `StructuralPartialEq` for type 
`errors::VaultError`
  --> contracts\vault\src\lib.rs:66:34
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                                  ^^^^^^^^^ conflicting implementation for `errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:50:34
   |
50 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                                  --------- first implementation here

error[E0119]: conflicting implementations of trait `PartialEq` for type `errors::VaultError`
  --> contracts\vault\src\lib.rs:66:34
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                                  ^^^^^^^^^ conflicting implementation for `errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:50:34
   |
50 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                                  --------- first implementation here

error[E0119]: conflicting implementations of trait `Ord` for type `errors::VaultError`
  --> contracts\vault\src\lib.rs:66:57
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                                                         ^^^ conflicting implementation for 
`errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:50:57
   |
50 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                                                         --- first implementation here

error[E0119]: conflicting implementations of trait `PartialOrd` for type `errors::VaultError`
  --> contracts\vault\src\lib.rs:66:45
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                                             ^^^^^^^^^^ conflicting implementation for 
`errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:50:45
   |
50 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                                             ---------- first implementation here

error[E0119]: conflicting implementations of trait `Copy` for type `errors::VaultError`
  --> contracts\vault\src\lib.rs:66:10
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |          ^^^^ conflicting implementation for `errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:50:10
   |
50 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |          ---- first implementation here

error[E0599]: no variant, associated function, or constant named `ProposalNotFound` found for enum 
`errors::VaultError` in the current scope
  --> contracts\vault\src\lib.rs:66:23
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                       ^^^^^ variant, associated function, or constant not found in 
`errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:51:1
   |
51 | pub enum VaultError {
   | ------------------- variant, associated function, or constant `ProposalNotFound` not found for 
this enum

error[E0599]: no variant, associated function, or constant named `TimelockNotExpired` found for 
enum `errors::VaultError` in the current scope
  --> contracts\vault\src\lib.rs:66:23
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                       ^^^^^ variant, associated function, or constant not found in 
`errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:51:1
   |
51 | pub enum VaultError {
   | ------------------- variant, associated function, or constant `TimelockNotExpired` not found 
for this enum

error[E0599]: no variant, associated function, or constant named `TimelockOverflow` found for enum 
`errors::VaultError` in the current scope
  --> contracts\vault\src\lib.rs:66:23
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                       ^^^^^ variant, associated function, or constant not found in 
`errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:51:1
   |
51 | pub enum VaultError {
   | ------------------- variant, associated function, or constant `TimelockOverflow` not found for 
this enum

error[E0599]: no variant, associated function, or constant named `InvalidTimelockWindow` found for 
enum `errors::VaultError` in the current scope
  --> contracts\vault\src\lib.rs:66:23
   |
66 | #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
   |                       ^^^^^ variant, associated function, or constant not found in 
`errors::VaultError`
   |
  ::: contracts\vault\src\errors.rs:51:1
   |
51 | pub enum VaultError {
   | ------------------- variant, associated function, or constant `InvalidTimelockWindow` not 
found for this enum

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:729:21
    |
729 |         if window < timelock::MIN_TIMELOCK_SECONDS || window > timelock::MAX_TIMELOCK_SECONDS 
{
    |                     ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:729:64
    |
729 |         if window < timelock::MIN_TIMELOCK_SECONDS || window > timelock::MAX_TIMELOCK_SECONDS 
{
    |                                                                ^^^^^^^^ use of unresolved 
module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0599]: no variant, associated function, or constant named `InvalidTimelockWindow` found for 
enum `errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:730:36
    |
730 |             return Err(VaultError::InvalidTimelockWindow);
    |                                    ^^^^^^^^^^^^^^^^^^^^^ variant, associated function, or 
constant not found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `InvalidTimelockWindow` not 
found for this enum

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:732:9
    |
732 |         timelock::set_timelock_window(&env, window);
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:738:14
    |
738 |             (timelock::get_timelock_window(&env), window),
    |              ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:748:9
    |
748 |         timelock::get_timelock_window(&env)
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:753:9
    |
753 |         timelock::get_pending_pause(&env)
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:758:9
    |
758 |         timelock::get_pending_upgrade(&env)
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:763:9
    |
763 |         timelock::get_pending_sweep(&env)
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0599]: no associated function or constant named `get_admin` found for struct `CalloraVault` 
in the current scope
   --> contracts\vault\src\lib.rs:769:27
    |
217 | pub struct CalloraVault;
    | ----------------------- associated function or constant `get_admin` not found for this struct
...
769 |         let admin = Self::get_admin(env.clone())?;
    |                           ^^^^^^^^^ associated function or constant not found in 
`CalloraVault`
    |
note: if you're trying to build a new `CalloraVault` consider using one of the following associated 
functions:
      CalloraVault::get_pending_pause
      CalloraVault::get_pending_upgrade
      CalloraVault::get_pending_sweep
   --> contracts\vault\src\lib.rs:752:5
    |
752 |     pub fn get_pending_pause(env: Env) -> Option<timelock::PendingPause> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
757 |     pub fn get_pending_upgrade(env: Env) -> Option<timelock::PendingUpgrade> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
762 |     pub fn get_pending_sweep(env: Env) -> Option<timelock::PendingSweep> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:792:22
    |
792 |         let window = timelock::get_timelock_window(&env);
    |                      ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:793:29
    |
793 |         let execute_after = timelock::saturating_deadline(proposed_at, window)
    |                             ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0599]: no variant, associated function, or constant named `TimelockOverflow` found for enum 
`errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:794:32
    |
794 |             .ok_or(VaultError::TimelockOverflow)?;
    |                                ^^^^^^^^^^^^^^^^ variant, associated function, or constant not 
found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `TimelockOverflow` not found 
for this enum

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:795:9
    |
795 |         timelock::set_pending_pause(
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:819:24
    |
819 |         let proposal = timelock::get_pending_pause(&env)
    |                        ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0599]: no variant, associated function, or constant named `ProposalNotFound` found for enum 
`errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:820:32
    |
820 |             .ok_or(VaultError::ProposalNotFound)?;
    |                                ^^^^^^^^^^^^^^^^ variant, associated function, or constant not 
found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `ProposalNotFound` not found 
for this enum

error[E0599]: no variant, associated function, or constant named `TimelockNotExpired` found for 
enum `errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:822:36
    |
822 |             return Err(VaultError::TimelockNotExpired);
    |                                    ^^^^^^^^^^^^^^^^^^ variant, associated function, or 
constant not found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `TimelockNotExpired` not found 
for this enum

error[E0599]: no variant, associated function, or constant named `Paused` found for enum 
`StorageKey` in the current scope
   --> contracts\vault\src\lib.rs:824:51
    |
168 | pub enum StorageKey {
    | ------------------- variant, associated function, or constant `Paused` not found for this enum
...
824 |         env.storage().instance().set(&StorageKey::Paused, &true);
    |                                                   ^^^^^^ variant, associated function, or 
constant not found in `StorageKey`

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:825:9
    |
825 |         timelock::clear_pending_pause(&env);
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:844:24
    |
844 |         let existing = timelock::get_pending_pause(&env);
    |                        ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:845:9
    |
845 |         timelock::clear_pending_pause(&env);
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:872:22
    |
872 |         let window = timelock::get_timelock_window(&env);
    |                      ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:873:29
    |
873 |         let execute_after = timelock::saturating_deadline(proposed_at, window)
    |                             ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0599]: no variant, associated function, or constant named `TimelockOverflow` found for enum 
`errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:874:32
    |
874 |             .ok_or(VaultError::TimelockOverflow)?;
    |                                ^^^^^^^^^^^^^^^^ variant, associated function, or constant not 
found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `TimelockOverflow` not found 
for this enum

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:875:9
    |
875 |         timelock::set_pending_upgrade(
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:898:24
    |
898 |         let proposal = timelock::get_pending_upgrade(&env)
    |                        ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0599]: no variant, associated function, or constant named `ProposalNotFound` found for enum 
`errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:899:32
    |
899 |             .ok_or(VaultError::ProposalNotFound)?;
    |                                ^^^^^^^^^^^^^^^^ variant, associated function, or constant not 
found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `ProposalNotFound` not found 
for this enum

error[E0599]: no variant, associated function, or constant named `TimelockNotExpired` found for 
enum `errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:901:36
    |
901 |             return Err(VaultError::TimelockNotExpired);
    |                                    ^^^^^^^^^^^^^^^^^^ variant, associated function, or 
constant not found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `TimelockNotExpired` not found 
for this enum

error[E0599]: no associated function or constant named `get_admin` found for struct `CalloraVault` 
in the current scope
   --> contracts\vault\src\lib.rs:904:27
    |
217 | pub struct CalloraVault;
    | ----------------------- associated function or constant `get_admin` not found for this struct
...
904 |         let admin = Self::get_admin(env.clone())?;
    |                           ^^^^^^^^^ associated function or constant not found in 
`CalloraVault`
    |
note: if you're trying to build a new `CalloraVault` consider using one of the following associated 
functions:
      CalloraVault::get_pending_pause
      CalloraVault::get_pending_upgrade
      CalloraVault::get_pending_sweep
   --> contracts\vault\src\lib.rs:752:5
    |
752 |     pub fn get_pending_pause(env: Env) -> Option<timelock::PendingPause> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
757 |     pub fn get_pending_upgrade(env: Env) -> Option<timelock::PendingUpgrade> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
762 |     pub fn get_pending_sweep(env: Env) -> Option<timelock::PendingSweep> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0599]: no variant, associated function, or constant named `ContractVersion` found for enum 
`StorageKey` in the current scope
   --> contracts\vault\src\lib.rs:908:31
    |
168 | pub enum StorageKey {
    | ------------------- variant, associated function, or constant `ContractVersion` not found for 
this enum
...
908 |             .set(&StorageKey::ContractVersion, &wasm_hash);
    |                               ^^^^^^^^^^^^^^^ variant, associated function, or constant not 
found in `StorageKey`

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:909:9
    |
909 |         timelock::clear_pending_upgrade(&env);
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:929:24
    |
929 |         let existing = timelock::get_pending_upgrade(&env);
    |                        ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:930:9
    |
930 |         timelock::clear_pending_upgrade(&env);
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:962:22
    |
962 |         let window = timelock::get_timelock_window(&env);
    |                      ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:963:29
    |
963 |         let execute_after = timelock::saturating_deadline(proposed_at, window)
    |                             ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0599]: no variant, associated function, or constant named `TimelockOverflow` found for enum 
`errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:964:32
    |
964 |             .ok_or(VaultError::TimelockOverflow)?;
    |                                ^^^^^^^^^^^^^^^^ variant, associated function, or constant not 
found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `TimelockOverflow` not found 
for this enum

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:965:9
    |
965 |         timelock::set_pending_sweep(
    |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:994:24
    |
994 |         let proposal = timelock::get_pending_sweep(&env)
    |                        ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0599]: no variant, associated function, or constant named `ProposalNotFound` found for enum 
`errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:995:32
    |
995 |             .ok_or(VaultError::ProposalNotFound)?;
    |                                ^^^^^^^^^^^^^^^^ variant, associated function, or constant not 
found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `ProposalNotFound` not found 
for this enum

error[E0599]: no variant, associated function, or constant named `TimelockNotExpired` found for 
enum `errors::VaultError` in the current scope
   --> contracts\vault\src\lib.rs:997:36
    |
997 |             return Err(VaultError::TimelockNotExpired);
    |                                    ^^^^^^^^^^^^^^^^^^ variant, associated function, or 
constant not found in `errors::VaultError`
    |
   ::: contracts\vault\src\errors.rs:51:1
    |
 51 | pub enum VaultError {
    | ------------------- variant, associated function, or constant `TimelockNotExpired` not found 
for this enum

error[E0433]: cannot find module or crate `timelock` in this scope
    --> contracts\vault\src\lib.rs:1023:9
     |
1023 |         timelock::clear_pending_sweep(&env);
     |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
     |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
     |
  20 + mod timelock;
     |

error[E0433]: cannot find module or crate `timelock` in this scope
    --> contracts\vault\src\lib.rs:1037:24
     |
1037 |         let existing = timelock::get_pending_sweep(&env);
     |                        ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
     |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
     |
  20 + mod timelock;
     |

error[E0433]: cannot find module or crate `timelock` in this scope
    --> contracts\vault\src\lib.rs:1038:9
     |
1038 |         timelock::clear_pending_sweep(&env);
     |         ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
     |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
     |
  20 + mod timelock;
     |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:797:14
    |
797 |             &timelock::PendingPause {
    |              ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:757:52
    |
757 |     pub fn get_pending_upgrade(env: Env) -> Option<timelock::PendingUpgrade> {
    |                                                    ^^^^^^^^ use of unresolved module or 
unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:877:14
    |
877 |             &timelock::PendingUpgrade {
    |              ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:762:50
    |
762 |     pub fn get_pending_sweep(env: Env) -> Option<timelock::PendingSweep> {
    |                                                  ^^^^^^^^ use of unresolved module or 
unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:967:14
    |
967 |             &timelock::PendingSweep {
    |              ^^^^^^^^ use of unresolved module or unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

error[E0433]: cannot find module or crate `timelock` in this scope
   --> contracts\vault\src\lib.rs:752:50
    |
752 |     pub fn get_pending_pause(env: Env) -> Option<timelock::PendingPause> {
    |                                                  ^^^^^^^^ use of unresolved module or 
unlinked crate `timelock`
    |
help: to make use of source file contracts\vault\src\timelock.rs, use `mod timelock` in this file 
to declare the module
    |
 20 + mod timelock;
    |

Some errors have detailed explanations: E0119, E0255, E0425, E0432, E0433, E0599.
For more information about an error, try `rustc --explain E0119`.
warning: `callora-vault` (lib) generated 5 warnings
error: could not compile `callora-vault` (lib) due to 66 previous errors; 5 warnings emitted