expire.rs

use crate::{cache, gdev, indexer::*, Args, Client};

use anyhow::Result;
use futures::join;
use std::collections::BTreeMap;

pub async fn monitor_expirations(
    client: Client,
    blocks: u32,
    sessions: u32,
    args: &Args,
) -> Result<()> {
    let gql_client = reqwest::Client::builder()
        .user_agent("gcli/0.1.0")
        .build()?;

    let parent_hash = client
        .storage()
        .fetch(&gdev::storage().system().parent_hash(), None)
        .await?
        .unwrap();
    let addr_current_block = gdev::storage().system().number();
    let addr_current_session = gdev::storage().session().current_index();
    let (current_block, current_session) = join!(
        client
            .storage()
            .fetch(&addr_current_block, Some(parent_hash)),
        client
            .storage()
            .fetch(&addr_current_session, Some(parent_hash),)
    );
    let current_block = current_block?.unwrap();
    let current_session = current_session?.unwrap();

    let end_block = current_block + blocks;
    let end_session = current_session + sessions;

    let mut identity_cache = cache::IdentityCache::new(
        &client,
        if args.no_indexer {
            None
        } else {
            Some(Indexer {
                gql_client,
                gql_url: &args.indexer,
            })
        },
    );

    // Rotate keys
    let mut must_rotate_keys_before_iter = client
        .storage()
        .iter(
            gdev::storage()
                .authority_members()
                .must_rotate_keys_before(0),
            10,
            Some(parent_hash),
        )
        .await?;
    let mut must_rotate_keys_before = BTreeMap::new();
    while let Some((k, v)) = must_rotate_keys_before_iter.next().await? {
        let session_index = u32::from_le_bytes(k.as_ref()[40..44].try_into().unwrap());
        if session_index < end_session {
            must_rotate_keys_before.insert(session_index - current_session, v);
        }
    }

    println!("\nAuthority members:");
    for (sessions_left, identity_ids) in must_rotate_keys_before {
        println!("Must rotate keys before {sessions_left} sessions:");
        for identity_id in identity_ids {
            println!(
                "  {} ({})",
                identity_cache
                    .fetch_identity(identity_id, parent_hash)
                    .await
                    .unwrap_or_else(|_| "?".into()),
                identity_id
            );
        }
    }

    // Certifications
    let mut basic_certs_iter = client
        .storage()
        .iter(
            gdev::storage().cert().storage_certs_removable_on(0),
            10,
            Some(parent_hash),
        )
        .await?;
    let mut basic_certs = BTreeMap::new();
    while let Some((k, v)) = basic_certs_iter.next().await? {
        let block_number = u32::from_le_bytes(k.as_ref()[40..44].try_into().unwrap());
        if block_number < end_block {
            basic_certs.insert(block_number - current_block, v);
        }
    }

    let mut smith_certs_iter = client
        .storage()
        .iter(
            gdev::storage().smiths_cert().storage_certs_removable_on(0),
            10,
            Some(parent_hash),
        )
        .await?;
    let mut smith_certs = BTreeMap::new();
    while let Some((k, v)) = smith_certs_iter.next().await? {
        let block_number = u32::from_le_bytes(k.as_ref()[40..44].try_into().unwrap());
        if block_number < end_block {
            smith_certs.insert(block_number - current_block, v);
        }
    }

    for (title, certs) in [
        ("Certifications", basic_certs),
        ("Smith certifications", smith_certs),
    ] {
        println!("\n{title}:");
        for (blocks_left, certs) in certs {
            println!("{blocks_left} blocks before expiration:");
            for (issuer_id, receiver_id) in certs {
                println!(
                    "  {} ({}) -> {} ({})",
                    identity_cache
                        .fetch_identity(issuer_id, parent_hash)
                        .await
                        .unwrap_or_else(|_| "?".into()),
                    issuer_id,
                    identity_cache
                        .fetch_identity(receiver_id, parent_hash)
                        .await
                        .unwrap_or_else(|_| "?".into()),
                    receiver_id,
                );
            }
        }
    }

    // Memberships
    let mut basic_membership_iter = client
        .storage()
        .iter(
            gdev::storage().membership().memberships_expire_on(0),
            10,
            Some(parent_hash),
        )
        .await?;
    let mut basic_memberships = BTreeMap::new();
    while let Some((k, v)) = basic_membership_iter.next().await? {
        let block_number = u32::from_le_bytes(k.as_ref()[40..44].try_into().unwrap());
        if block_number < end_block {
            basic_memberships.insert(block_number - current_block, v);
        }
    }

    let mut smith_membership_iter = client
        .storage()
        .iter(
            gdev::storage().smiths_membership().memberships_expire_on(0),
            10,
            Some(parent_hash),
        )
        .await?;
    let mut smith_memberships = BTreeMap::new();
    while let Some((k, v)) = smith_membership_iter.next().await? {
        let block_number = u32::from_le_bytes(k.as_ref()[40..44].try_into().unwrap());
        if block_number < end_block {
            smith_memberships.insert(block_number - current_block, v);
        }
    }

    for (title, memberships) in [
        ("Memberships", basic_memberships),
        ("Smith memberships", smith_memberships),
    ] {
        println!("\n{title}:");
        for (blocks_left, membership) in memberships {
            println!("{blocks_left} blocks before expiration:");
            for identity_id in membership {
                println!(
                    "  {} ({})",
                    identity_cache
                        .fetch_identity(identity_id, parent_hash)
                        .await
                        .unwrap_or_else(|_| "?".into()),
                    identity_id,
                );
            }
        }
    }

    Ok(())
}