Struct primitives::sentry::AccountingResponse

pub struct AccountingResponse<S: BalancesState> {
    pub balances: Balances<S>,
}

Channel Accounting response

A collection of all Accountings for a specific Channel

Examples

use primitives::{balances::CheckedState, sentry::AccountingResponse};
use serde_json::{from_value, json};

fn main() {
    // Empty balances
    {
        let json = json!({
          "earners": {},
          "spenders": {},
        });
        assert!(from_value::<AccountingResponse::<CheckedState>>(json).is_ok());
    }

    // Non-empty balances
    {
        // earners sum and spenders sum should always match since balances are CheckedState
        let json = json!({
            "earners": {
                "0x80690751969B234697e9059e04ed72195c3507fa": "10000000000",
                "0xf3f583AEC5f7C030722Fe992A5688557e1B86ef7": "20000000000",
                "0xE882ebF439207a70dDcCb39E13CA8506c9F45fD9": "30000000000",
            },
            "spenders": {
                "0xaCBaDA2d5830d1875ae3D2de207A1363B316Df2F": "60000000000",
            },
        });
        assert!(from_value::<AccountingResponse::<CheckedState>>(json).is_ok());
    }
}

Fields

balances: Balances<S>

Trait Implementations

impl<S: Clone + BalancesState> Clone for AccountingResponse<S>

fn clone(&self) -> AccountingResponse<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug + BalancesState> Debug for AccountingResponse<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, S: BalancesState> Deserialize<'de> for AccountingResponse<S>where
    S: BalancesState,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: PartialEq + BalancesState> PartialEq<AccountingResponse<S>> for AccountingResponse<S>

fn eq(&self, other: &AccountingResponse<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: BalancesState> Serialize for AccountingResponse<S>where
    S: BalancesState,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Eq + BalancesState> Eq for AccountingResponse<S>

impl<S: BalancesState> StructuralEq for AccountingResponse<S>

impl<S: BalancesState> StructuralPartialEq for AccountingResponse<S>