diff --git a/gtest/src/lib.rs b/gtest/src/lib.rs index 0fe769f8b12..8af87e430c6 100644 --- a/gtest/src/lib.rs +++ b/gtest/src/lib.rs @@ -29,20 +29,73 @@ pub use error::{Result, TestError}; pub use program::{calculate_program_id, Gas, Program, WasmProgram}; pub use system::System; -pub const EXISTENTIAL_DEPOSIT: u128 = 500; -pub const MAILBOX_THRESHOLD: u64 = 3000; -pub const WAITLIST_COST: u64 = 100; -pub const RESERVE_FOR: u32 = 1; -pub const RESERVATION_COST: u64 = 100; -pub const READ_COST: u64 = 20; -pub const WRITE_COST: u64 = 100; -pub const READ_PER_BYTE_COST: u64 = 10; -pub const WRITE_PER_BYTE_COST: u64 = 10; -pub const MODULE_INSTANTIATION_BYTE_COST: u64 = 20; -pub const MAX_RESERVATIONS: u64 = 256; -pub const EPOCH_DURATION_IN_BLOCKS: u32 = 600; -pub const INITIAL_RANDOM_SEED: u64 = 42; -pub const MODULE_INSTRUMENTATION_BYTE_COST: u64 = 13; -pub const MODULE_INSTRUMENTATION_COST: u64 = 297; -pub const DISPATCH_HOLD_COST: u64 = 200; -pub const RENT_COST: u128 = 330; +pub(crate) use constants::*; + +/// Module containing constants of Gear protocol. +pub mod constants { + /* Constant types */ + + /// Numeric type representing value in Gear protocol. + pub type Value = u128; + + /// Numeric type representing gas in Gear protocol. + pub type Gas = u64; + + /// Numeric type representing blocks in Gear protocol. + pub type Block = u32; + + /* Currency-related constants */ + + /// Value per token. + pub const UNITS: Value = 1_000_000_000_000; + /// Minimal amount of value able to be sent. Defines accounts existence + /// requirement. + pub const EXISTENTIAL_DEPOSIT: Value = 10 * UNITS; + /// Value per gas. + pub const VALUE_PER_GAS: Value = 25; + /// Duration of one epoch. + pub const EPOCH_DURATION_IN_BLOCKS: Block = 600; + + /* Storage-related constants */ + // TODO: use proper weights of db accesses (#3509). + + /// Minimal amount of gas required to be inserted into Mailbox. + pub const MAILBOX_THRESHOLD: Gas = 3_000; + /// Extra amount of blocks must be reserved for storing in storage. + pub const RESERVE_FOR: Block = 1; + /// Cost of read access into storage. + pub const READ_COST: Gas = 25; + /// Per-byte extra cost of read access into storage. + pub const READ_PER_BYTE_COST: Gas = 10; + /// Cost of write access into storage. + pub const WRITE_COST: Gas = 100; + /// Per-byte extra cost of write access into storage. + pub const WRITE_PER_BYTE_COST: Gas = 10; + + /* Rent-related constants */ + + /// Cost of storing waitlisted message per block. + pub const WAITLIST_COST: Gas = 100; + /// Cost of storing reservation per block. + pub const RESERVATION_COST: Gas = 100; + /// Cost of storing delayed message per block. + pub const DISPATCH_HOLD_COST: Gas = 100; + /// Cost of storing program per block. + /// + /// (!) Currently disabled: storing programs are free. + pub const RENT_COST: Value = 330; + + /* Execution-related constants */ + // TODO: use proper weights of instantiation and instrumentation (#3509). + + /// Maximal amount of reservations program may have. + pub const MAX_RESERVATIONS: u64 = 256; + /// Cost of wasm module instantiation before execution per byte of code. + pub const MODULE_INSTANTIATION_BYTE_COST: Gas = 20; + /// Cost of instrumenting wasm code on upload. + pub const MODULE_INSTRUMENTATION_COST: Gas = 297; + /// Cost of instrumenting wasm code on upload per byte of code. + pub const MODULE_INSTRUMENTATION_BYTE_COST: Gas = 13; + /// Initial random seed for testing environment. + pub const INITIAL_RANDOM_SEED: u64 = 42; +} diff --git a/gtest/src/mailbox.rs b/gtest/src/mailbox.rs index 376a41dd64b..0a427732bc4 100644 --- a/gtest/src/mailbox.rs +++ b/gtest/src/mailbox.rs @@ -357,17 +357,20 @@ mod tests { receiver_id.into(), payload.encode().try_into().unwrap(), Default::default(), - 1000, + 2 * crate::EXISTENTIAL_DEPOSIT, None, ); - system.mint_to(sender_id, 1000); + system.mint_to(sender_id, 2 * crate::EXISTENTIAL_DEPOSIT); system.send_dispatch(Dispatch::new(DispatchKind::Handle, message)); let receiver_mailbox = system.get_mailbox(receiver_id); receiver_mailbox.claim_value(log); - assert_eq!(system.balance_of(receiver_id), 1000); + assert_eq!( + system.balance_of(receiver_id), + 2 * crate::EXISTENTIAL_DEPOSIT + ); } #[test] diff --git a/gtest/src/program.rs b/gtest/src/program.rs index 75117f9e874..fdda6f22b24 100644 --- a/gtest/src/program.rs +++ b/gtest/src/program.rs @@ -700,8 +700,8 @@ mod tests { sys.init_logger(); let user_id = 42; - sys.mint_to(user_id, 5000); - assert_eq!(sys.balance_of(user_id), 5000); + sys.mint_to(user_id, 10 * crate::EXISTENTIAL_DEPOSIT); + assert_eq!(sys.balance_of(user_id), 10 * crate::EXISTENTIAL_DEPOSIT); let mut prog = Program::from_opt_and_meta_code_with_id( &sys, @@ -710,16 +710,16 @@ mod tests { None, ); - prog.mint(1000); - assert_eq!(prog.balance(), 1000); + prog.mint(2 * crate::EXISTENTIAL_DEPOSIT); + assert_eq!(prog.balance(), 2 * crate::EXISTENTIAL_DEPOSIT); - prog.send_with_value(user_id, "init".to_string(), 500); - assert_eq!(prog.balance(), 1500); - assert_eq!(sys.balance_of(user_id), 4500); + prog.send_with_value(user_id, "init".to_string(), crate::EXISTENTIAL_DEPOSIT); + assert_eq!(prog.balance(), 3 * crate::EXISTENTIAL_DEPOSIT); + assert_eq!(sys.balance_of(user_id), 9 * crate::EXISTENTIAL_DEPOSIT); - prog.send_with_value(user_id, "PING".to_string(), 1000); - assert_eq!(prog.balance(), 2500); - assert_eq!(sys.balance_of(user_id), 3500); + prog.send_with_value(user_id, "PING".to_string(), 2 * crate::EXISTENTIAL_DEPOSIT); + assert_eq!(prog.balance(), 5 * crate::EXISTENTIAL_DEPOSIT); + assert_eq!(sys.balance_of(user_id), 7 * crate::EXISTENTIAL_DEPOSIT); } #[test] @@ -733,9 +733,9 @@ mod tests { let sender2 = 45; // Top-up senders balances - sys.mint_to(sender0, 10000); - sys.mint_to(sender1, 10000); - sys.mint_to(sender2, 10000); + sys.mint_to(sender0, 20 * crate::EXISTENTIAL_DEPOSIT); + sys.mint_to(sender1, 20 * crate::EXISTENTIAL_DEPOSIT); + sys.mint_to(sender2, 20 * crate::EXISTENTIAL_DEPOSIT); let prog = Program::from_opt_and_meta_code_with_id( &sys, @@ -748,27 +748,32 @@ mod tests { assert_eq!(prog.balance(), 0); // Send values to the program - prog.send_bytes_with_value(sender0, b"insert", 1000); - assert_eq!(sys.balance_of(sender0), 9000); - prog.send_bytes_with_value(sender1, b"insert", 2000); - assert_eq!(sys.balance_of(sender1), 8000); - prog.send_bytes_with_value(sender2, b"insert", 3000); - assert_eq!(sys.balance_of(sender2), 7000); + prog.send_bytes_with_value(sender0, b"insert", 2 * crate::EXISTENTIAL_DEPOSIT); + assert_eq!(sys.balance_of(sender0), 18 * crate::EXISTENTIAL_DEPOSIT); + prog.send_bytes_with_value(sender1, b"insert", 4 * crate::EXISTENTIAL_DEPOSIT); + assert_eq!(sys.balance_of(sender1), 16 * crate::EXISTENTIAL_DEPOSIT); + prog.send_bytes_with_value(sender2, b"insert", 6 * crate::EXISTENTIAL_DEPOSIT); + assert_eq!(sys.balance_of(sender2), 14 * crate::EXISTENTIAL_DEPOSIT); // Check program's balance - assert_eq!(prog.balance(), 1000 + 2000 + 3000); + assert_eq!(prog.balance(), (2 + 4 + 6) * crate::EXISTENTIAL_DEPOSIT); // Request to smash the piggy bank and send the value to the receiver address prog.send_bytes(receiver, b"smash"); sys.claim_value_from_mailbox(receiver); - assert_eq!(sys.balance_of(receiver), 1000 + 2000 + 3000); + assert_eq!( + sys.balance_of(receiver), + (2 + 4 + 6) * crate::EXISTENTIAL_DEPOSIT + ); // Check program's balance is empty assert_eq!(prog.balance(), 0); } #[test] - #[should_panic(expected = "An attempt to mint value (1) less than existential deposit (500)")] + #[should_panic( + expected = "An attempt to mint value (1) less than existential deposit (10000000000000)" + )] fn mint_less_than_deposit() { System::new().mint_to(1, 1); } @@ -776,7 +781,7 @@ mod tests { #[test] #[should_panic(expected = "Insufficient value: user \ (0x0100000000000000000000000000000000000000000000000000000000000000) tries \ - to send (501) value, while his balance (500)")] + to send (10000000000001) value, while his balance (10000000000000)")] fn fails_on_insufficient_balance() { let sys = System::new(); @@ -803,7 +808,7 @@ mod tests { let sender = 42; let receiver = 84; - sys.mint_to(sender, 10000); + sys.mint_to(sender, 20 * crate::EXISTENTIAL_DEPOSIT); let prog = Program::from_opt_and_meta_code_with_id( &sys,