expire.rs

use crate::*;

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

pub async fn monitor_expirations(data: &Data, blocks: u32, _sessions: u32) -> anyhow::Result<()> {
	let client = data.client();
	let indexer = data.indexer.clone();

	let parent_hash = client
		.storage()
		.at_latest()
		.await?
		.fetch(&runtime::storage().system().parent_hash())
		.await?
		.unwrap();
	let addr_current_block = runtime::storage().system().number();
	let addr_current_session = runtime::storage().session().current_index();
	let (current_block, _current_session) = join!(
		client.storage().at(parent_hash).fetch(&addr_current_block),
		client
			.storage()
			.at(parent_hash)
			.fetch(&addr_current_session)
	);
	let current_block = current_block?.unwrap_or_default();

	let end_block = current_block + blocks;

	let mut identity_cache = cache::IdentityCache::new(client.clone(), indexer);

	// Certifications
	let mut basic_certs_iter = client
		.storage()
		.at(parent_hash)
		.iter(runtime::storage().cert().storage_certs_removable_on_iter())
		.await?;
	let mut basic_certs = BTreeMap::new();
	while let Some(Ok((k, v))) = basic_certs_iter.next().await {
		let block_number = BlockNumber::from_le_bytes(k[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()
		.at(parent_hash)
		.iter(
			runtime::storage()
				.smith_cert()
				.storage_certs_removable_on_iter(),
		)
		.await?;
	let mut smith_certs = BTreeMap::new();
	while let Some(Ok((k, v))) = smith_certs_iter.next().await {
		let block_number = BlockNumber::from_le_bytes(k[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()
		.at(parent_hash)
		.iter(runtime::storage().membership().memberships_expire_on_iter())
		.await?;
	let mut basic_memberships = BTreeMap::new();
	while let Some(Ok((k, v))) = basic_membership_iter.next().await {
		let block_number = BlockNumber::from_le_bytes(k[40..44].try_into().unwrap());
		if block_number < end_block {
			if block_number < current_block {
				dbg!((block_number, current_block));
			}
			basic_memberships.insert(block_number - current_block, v);
		}
	}

	let mut smith_membership_iter = client
		.storage()
		.at(parent_hash)
		.iter(
			runtime::storage()
				.smith_membership()
				.memberships_expire_on_iter(),
		)
		.await?;
	let mut smith_memberships = BTreeMap::new();
	while let Some(Ok((k, v))) = smith_membership_iter.next().await {
		let block_number = BlockNumber::from_le_bytes(k[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(())
}