Minimal bids in delegations, the skeleton (#577)

* Validator Info Api
* Validator Info with minimum delegation rate.
TODO: Make delegation rate work in OdraVM
* Fix delegation
* Rewards rework

---------

Co-authored-by: Kuba <kuba@odra.dev>

Author: kubaplas

core/src/consts.rs

@@ -65,5 +65,7 @@ pub const ACCOUNTS_NUMBER: u8 = 20;
 
 pub const DEFAULT_BALANCE: u64 = 10_000_000_000_000_000_000;
 
+pub const DEFAULT_MINIMUM_DELEGATION_AMOUNT: u64 = 500_000_000_000u64;
+
 /// Amount of random bytes returned by pseudorandom_bytes
 pub const RANDOM_BYTES_COUNT: usize = 32;

core/src/contract_context.rs

@@ -1,10 +1,10 @@
-use casper_types::{CLValue, PublicKey};
-
 use crate::call_def::CallDef;
 use crate::casper_types::bytesrepr::Bytes;
 use crate::casper_types::U512;
 use crate::consts::RANDOM_BYTES_COUNT;
 use crate::prelude::*;
+use crate::validator::ValidatorInfo;
+use casper_types::{CLValue, PublicKey};
 
 /// Trait representing the context of a smart contract.
 #[cfg_attr(test, allow(unreachable_code))]
@@ -202,6 +202,15 @@ pub trait ContractContext {
     /// The amount of tokens delegated to the validator as a `U512` value.
     fn delegated_amount(&self, validator: PublicKey) -> U512;
 
+    /// Returns information about the validator
+    ///
+    /// # Arguments
+    /// - validator - The validator to query
+    ///
+    /// # Returns
+    /// Option<ValidatorBid>
+    fn get_validator_info(&self, validator: PublicKey) -> Option<ValidatorInfo>;
+
     /// Returns a vector of pseudorandom bytes of the specified size.
     /// There is no guarantee that the returned bytes are in any way cryptographically secure.
     fn pseudorandom_bytes(&self) -> [u8; RANDOM_BYTES_COUNT];

core/src/contract_env.rs

@@ -4,6 +4,7 @@ use crate::casper_types::bytesrepr::{deserialize_from_slice, Bytes, FromBytes, T
 use crate::casper_types::crypto::PublicKey;
 use crate::casper_types::{CLTyped, CLValue, BLAKE2B_DIGEST_LENGTH, U512};
 use crate::module::Revertible;
+use crate::validator::ValidatorInfo;
 pub use crate::ContractContext;
 use crate::VmError::{Serialization, TypeMismatch};
 use crate::{consts, prelude::*, utils};
@@ -315,6 +316,17 @@ impl ContractEnv {
         self.backend.borrow().delegated_amount(validator)
     }
 
+    /// Returns information about the validator
+    ///
+    /// # Arguments
+    /// - validator - The validator to query
+    ///
+    /// # Returns
+    /// Option<ValidatorBid>
+    pub fn get_validator_info(&self, validator: PublicKey) -> Option<ValidatorInfo> {
+        self.backend.borrow().get_validator_info(validator)
+    }
+
     /// Returns a vector of pseudorandom bytes of the specified size.
     /// There is no guarantee that the returned bytes are in any way cryptographically secure.
     pub fn pseudorandom_bytes(&self, size: usize) -> Vec<u8> {

core/src/lib.rs

@@ -34,6 +34,7 @@ mod sequence;
 pub mod uints;
 mod unwrap_or_revert;
 pub mod utils;
+pub mod validator;
 mod var;
 
 pub use call_def::CallDef;

core/src/validator.rs

@@ -0,0 +1,31 @@
+//! Validator related types.
+use casper_types::U512;
+
+/// ValidatorInfo contains information about a validator.
+#[derive(Clone, Debug)]
+pub struct ValidatorInfo {
+    /// The amount of tokens staked.
+    pub staked_amount: U512,
+    /// The minimum amount of tokens that must be delegated to the validator.
+    pub minimum_delegation_amount: u64
+}
+
+impl ValidatorInfo {
+    /// Creates a new ValidatorInfo with the given staked amount and minimum delegation amount.
+    pub fn new(staked_amount: U512, minimum_delegation_amount: u64) -> Self {
+        ValidatorInfo {
+            staked_amount,
+            minimum_delegation_amount
+        }
+    }
+
+    /// Sets the ValidatorInfo with the staked amount set to the given value.
+    pub fn set_staked_amount(&mut self, staked_amount: U512) {
+        self.staked_amount = staked_amount;
+    }
+
+    /// Sets the ValidatorInfo with the minimum delegation amount set to the given value.
+    pub fn set_minimum_delegation_amount(&mut self, minimum_delegation_amount: u64) {
+        self.minimum_delegation_amount = minimum_delegation_amount;
+    }
+}

examples/src/features/validators.rs

@@ -48,6 +48,14 @@ impl ValidatorsContract {
     pub fn current_casper_balance(&self) -> U512 {
         self.env().self_balance()
     }
+
+    /// Get minimum delegation amount
+    pub fn get_minimum_delegation_amount(&self) -> u64 {
+        self.env()
+            .get_validator_info(self.validator.get().unwrap())
+            .unwrap()
+            .minimum_delegation_amount
+    }
 }
 
 /// Error enum for the ValidatorsContract
@@ -233,4 +241,24 @@ mod tests {
         assert_eq!(staking.currently_delegated_amount(), U512::zero());
         assert_eq!(test_env.balance_of(&staking.address()), staking_amount);
     }
+
+    #[test]
+    fn test_validator_info() {
+        use crate::features::validators::{ValidatorsContract, ValidatorsContractInitArgs};
+        use odra::host::Deployer;
+        let test_env = odra_test::env();
+        let validator = test_env.get_validator(0);
+
+        test_env.set_caller(test_env.get_account(0));
+        let staking = ValidatorsContract::deploy(
+            &test_env,
+            ValidatorsContractInitArgs {
+                validator: validator.clone()
+            }
+        );
+
+        let minimum_delegation_amount = staking.get_minimum_delegation_amount();
+
+        assert_eq!(minimum_delegation_amount, 500_000_000_000u64);
+    }
 }

odra-casper/livenet-env/src/livenet_contract_env.rs

@@ -6,6 +6,7 @@ use odra_core::callstack::{Callstack, CallstackElement};
 use odra_core::casper_types::bytesrepr::Bytes;
 use odra_core::casper_types::{CLValue, PublicKey, U512};
 use odra_core::prelude::*;
+use odra_core::validator::ValidatorInfo;
 use odra_core::{CallDef, ContractContext, ContractRegister};
 use std::io::Write;
 use std::sync::RwLock;
@@ -187,6 +188,10 @@ impl ContractContext for LivenetContractEnv {
             .block_on(async { client.delegated_amount(address, _validator).await })
     }
 
+    fn get_validator_info(&self, _validator: PublicKey) -> Option<ValidatorInfo> {
+        todo!()
+    }
+
     fn pseudorandom_bytes(&self) -> [u8; 32] {
         panic!(
             "pseudorandom_bytes is not supported for LivenetContractEnv, it should be run\

odra-casper/rpc-client/src/casper_client.rs

@@ -23,7 +23,7 @@ use casper_client::{
 };
 use casper_types::bytesrepr::{deserialize_from_slice, Bytes, ToBytes};
 use casper_types::execution::ExecutionResultV1::{Failure, Success};
-use casper_types::system::auction::BidAddr;
+use casper_types::system::auction::{BidAddr, ValidatorBid};
 use casper_types::StoredValue::CLValue;
 use casper_types::{
     execution::ExecutionResult, runtime_args, sign, CLTyped, Digest, EntityAddr, Key, PricingMode,
@@ -189,6 +189,10 @@ impl CasperClient {
         }
     }
 
+    pub async fn get_validator_info(&self, _validator: PublicKey) -> Option<ValidatorBid> {
+        todo!("Implement get_validator_info")
+    }
+
     pub async fn auction_delay(&self) -> u64 {
         let chainspec = self.chainspec().await;
 

odra-casper/test-vm/src/vm/casper_vm.rs

@@ -136,7 +136,7 @@ impl CasperVm {
 
             let step_request = step_request_builder.build();
             self.context.step(step_request);
-            self.context.advance_eras_by_default_auction_delay();
+            self.context.advance_era();
             self.advance_block_time(time_between_auctions);
             self.context
                 .distribute(None, DEFAULT_PROTOCOL_VERSION, rewards, self.block_time);
@@ -710,7 +710,6 @@ impl CasperVm {
             builder.exec(bid_request).commit().expect_success();
         }
 
-        builder.advance_eras_by(20);
         Self {
             active_account: accounts[0],
             context: builder,

odra-casper/wasm-env/src/host_functions.rs

@@ -29,7 +29,7 @@ use odra_core::casper_types::account::AccountHash;
 use odra_core::casper_types::bytesrepr::deserialize;
 use odra_core::casper_types::contract_messages::{MessagePayload, MessageTopicOperation};
 use odra_core::casper_types::contracts::{ContractHash, ContractPackageHash, ContractVersion};
-use odra_core::casper_types::system::auction::{self, BidAddr, BidKind};
+use odra_core::casper_types::system::auction::{self, BidAddr, BidKind, ValidatorBid};
 use odra_core::casper_types::system::{Caller, CallerInfo};
 use odra_core::casper_types::StoredValue;
 use odra_core::casper_types::{
@@ -41,6 +41,7 @@ use odra_core::casper_types::{
 use odra_core::consts::{
     ALLOW_KEY_OVERRIDE_ARG, IS_UPGRADABLE_ARG, PACKAGE_HASH_KEY_NAME_ARG, RANDOM_BYTES_COUNT
 };
+use odra_core::validator::ValidatorInfo;
 use odra_core::{
     args::EntrypointArgument,
     casper_event_standard::{self, Schema, Schemas}
@@ -832,3 +833,23 @@ pub fn delegated_amount(public_key: PublicKey) -> U512 {
 pub fn pseudorandom_bytes() -> [u8; RANDOM_BYTES_COUNT] {
     runtime::random_bytes()
 }
+
+/// Retrieves ValidatorBid from the storage
+pub fn get_validator_info(validator: PublicKey) -> Option<ValidatorInfo> {
+    let account_hash = validator.to_account_hash();
+    let key = Key::BidAddr(BidAddr::Validator(account_hash));
+
+    read_from_key(key)
+        .ok()
+        .and_then(|stored_value| stored_value)
+        .and_then(|bid_kind| match bid_kind {
+            BidKind::Validator(bid) => Some(*bid),
+            _ => None
+        })
+        .map(|validator_bid| {
+            ValidatorInfo::new(
+                validator_bid.staked_amount(),
+                validator_bid.minimum_delegation_amount()
+            )
+        })
+}