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()
		.fetch(&runtime::storage().system().parent_hash(), None)
		.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()
			.fetch(&addr_current_block, Some(parent_hash)),
		client
			.storage()
			.fetch(&addr_current_session, Some(parent_hash),)
	);
	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()
		.iter(
			runtime::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(
			runtime::storage()
				.smith_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(
			runtime::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 {
			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()
		.iter(
			runtime::storage()
				.smith_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(())
}