verity_ic/remittance/

utils.rs

use super::{ types::{ Account, RemittanceReciept, WithheldAccount }, DC_CANISTERS };
use crate::crypto::string_to_vec_u8;
use candid::Principal;
use easy_hasher::easy_hasher;
use eth_encode_packed::{ ethabi::{ ethereum_types::U256, Address }, SolidityDataType };
use ic_cdk::{ api::time, caller };

/// Ensures the caller is a whitelisted DC canister, otherwise panics.
/// This function checks if the caller's principal ID is in the list of allowed DC canisters.
pub fn only_whitelisted_dc_canister() {
	let caller_principal_id = caller();
	if !DC_CANISTERS.with(|publisher| publisher.borrow().contains(&caller_principal_id)) {
		panic!("NOT_ALLOWED");
	}
}

/// Hashes the parameters needed for a remittance transaction.
///
/// # Parameters
/// - `nonce`: A unique number to ensure the transaction is unique.
/// - `amount`: The amount to be remitted.
/// - `address`: The recipient's Ethereum address.
/// - `chain_id`: The ID of the blockchain network.
/// - `dc_canister_id`: The ID of the DC canister.
/// - `token_address`: The address of the token being transferred.
///
/// # Returns
/// A vector of bytes representing the hashed parameters.
pub fn hash_remittance_parameters(
	nonce: u64,
	amount: u64,
	address: &str,
	chain_id: &str,
	dc_canister_id: &str,
	token_address: &str
) -> Vec<u8> {
	// convert the address to bytes format
	let address: [u8; 20] = string_to_vec_u8(address).try_into().unwrap();
	let token_address: [u8; 20] = string_to_vec_u8(token_address).try_into().unwrap();

	// pack the encoded bytes
	let input = vec![
		SolidityDataType::Number(U256::from(nonce)),
		SolidityDataType::Number(U256::from(amount)),
		SolidityDataType::Address(Address::from(address)),
		SolidityDataType::String(chain_id),
		SolidityDataType::String(dc_canister_id),
		SolidityDataType::Address(Address::from(token_address))
	];
	let (_bytes, __) = eth_encode_packed::abi::encode_packed(&input);

	easy_hasher::raw_keccak256(_bytes.clone()).to_vec()
}

/// Retrieves the remitted balance for a given account and amount.
///
/// # Parameters
/// - `token`: The wallet token.
/// - `chain`: The blockchain chain.
/// - `account`: The user's wallet account.
/// - `dc_canister`: The principal of the DC canister.
/// - `amount`: The amount to check for remittance.
///
/// # Returns
/// A `WithheldAccount` containing the remitted balance or zero if no remittance exists.
pub fn get_remitted_balance(
	token: super::types::Wallet,
	chain: super::types::Chain,
	account: super::types::Wallet,
	dc_canister: Principal,
	amount: u64
) -> WithheldAccount {
	let withheld_amount = super::WITHHELD_REMITTANCE.with(|withheld| {
		let existing_key = (token, chain, account.clone(), dc_canister, amount);
		withheld.borrow().get(&existing_key).cloned().unwrap_or_default()
	});

	withheld_amount
}

/// Retrieves the total available balance for a user.
///
/// # Parameters
/// - `token`: The wallet token.
/// - `chain`: The blockchain chain.
/// - `account`: The user's wallet account.
/// - `dc_canister`: The principal of the DC canister.
///
/// # Returns
/// An `Account` containing the available balance.
pub fn get_available_balance(
	token: super::types::Wallet,
	chain: super::types::Chain,
	account: super::types::Wallet,
	dc_canister: Principal
) -> Account {
	let available_amount = super::REMITTANCE.with(|remittance| {
		let existing_key = (token, chain, account, dc_canister);
		remittance.borrow().get(&existing_key).cloned().unwrap_or_default()
	});

	available_amount
}

/// Retrieves the total balance available to a specific canister.
///
/// # Parameters
/// - `token`: The wallet token.
/// - `chain`: The blockchain chain.
/// - `dc_canister`: The principal of the DC canister.
///
/// # Returns
/// An `Account` containing the canister's balance.
pub fn get_canister_balance(
	token: super::types::Wallet,
	chain: super::types::Chain,
	dc_canister: Principal
) -> Account {
	let canister_balance = super::CANISTER_BALANCE.with(|cb| {
		let existing_key = (token, chain, dc_canister);
		cb.borrow().get(&existing_key).cloned().unwrap_or_default()
	});

	canister_balance
}

/// Updates the balance for a specific account in a DC canister within the remittance mapping.
///
/// # Parameters
/// - `new_remittance`: The new remittance data model.
/// - `dc_canister`: The principal of the DC canister.
pub fn update_balance(new_remittance: &super::types::DataModel, dc_canister: Principal) {
	super::REMITTANCE.with(|remittance| {
		let mut remittance_store = remittance.borrow_mut();

		let hash_key = (
			new_remittance.token.clone(),
			new_remittance.chain.clone(),
			new_remittance.account.clone(),
			dc_canister.clone(),
		);

		if let Some(existing_data) = remittance_store.get_mut(&hash_key) {
			existing_data.balance = ((existing_data.balance as i64) +
				(new_remittance.amount as i64)) as u64;
		} else {
			remittance_store.insert(hash_key, Account {
				balance: new_remittance.amount as u64,
			});
		}
	});
}

/// Updates the canister's balance for a specific token.
///
/// # Parameters
/// - `token`: The wallet token.
/// - `chain`: The blockchain chain.
/// - `dc_canister`: The principal of the DC canister.
/// - `amount`: The amount to update the balance by.
pub fn update_canister_balance(
	token: super::types::Wallet,
	chain: super::types::Chain,
	dc_canister: Principal,
	amount: i64
) {
	super::CANISTER_BALANCE.with(|canister_balance| {
		let mut canister_balance_store = canister_balance.borrow_mut();

		let hash_key = (token.clone(), chain.clone(), dc_canister.clone());

		if let Some(existing_data) = canister_balance_store.get_mut(&hash_key) {
			existing_data.balance = ((existing_data.balance as i64) + (amount as i64)) as u64;
		} else {
			canister_balance_store.insert(hash_key, Account {
				balance: amount as u64,
			});
		}
	});
}

/// Confirms a successful withdrawal by updating the necessary balances.
///
/// # Parameters
/// - `token`: The token involved in the transaction.
/// - `chain`: The blockchain chain.
/// - `account`: The user's wallet account.
/// - `amount_withdrawn`: The amount withdrawn.
/// - `dc_canister`: The principal of the DC canister.
///
/// # Returns
/// A boolean indicating the success of the withdrawal confirmation.
pub fn confirm_withdrawal(
	token: String,
	chain: String,
	account: String,
	amount_withdrawn: u64,
	dc_canister: Principal
) -> bool {
	let chain: super::types::Chain = chain.try_into().unwrap();
	let token: super::types::Wallet = token.try_into().unwrap();
	let account: super::types::Wallet = account.try_into().unwrap();

	let hash_key = (token.clone(), chain.clone(), account.clone(), dc_canister.clone());

	// go through the witheld amounts and remove this amount from it
	super::WITHHELD_AMOUNTS.with(|witheld_amounts| {
		let mut mut_witheld_amounts = witheld_amounts.borrow_mut();
		let unwithdrawn_amounts = mut_witheld_amounts
			.get(&hash_key)
			.expect("WITHDRAWAL_CONFIRMATION_ERROR:AMOUNT_NOT_WITHELD")
			.into_iter()
			.filter(|&amount_to_withdraw| *amount_to_withdraw != amount_withdrawn)
			.cloned()
			.collect();
		mut_witheld_amounts.insert(hash_key, unwithdrawn_amounts);
	});

	// go through the witheld balance store and remove this amount from it
	let withdrawn_details = super::WITHHELD_REMITTANCE.with(|withheld_remittance| {
		let key = (
			token.clone(),
			chain.clone(),
			account.clone(),
			dc_canister.clone(),
			amount_withdrawn,
		);
		let withdrawn_balance = withheld_remittance.borrow().get(&key).unwrap().clone();
		withheld_remittance.borrow_mut().remove(&key);

		withdrawn_balance
	});

	// create a reciept entry here for a succcessfull withdrawal
	super::REMITTANCE_RECIEPTS.with(|remittance_reciepts| {
		remittance_reciepts
			.borrow_mut()
			.insert((dc_canister, withdrawn_details.nonce), RemittanceReciept {
				token: token.to_string(),
				chain: chain.to_string(),
				amount: amount_withdrawn,
				account: account.to_string(),
				timestamp: time(),
			});
	});
	return true;
}

/// Cancels a withdrawal request, returning the withheld amount to the available balance.
///
/// # Parameters
/// - `token`: The token involved in the transaction.
/// - `chain`: The blockchain chain.
/// - `account`: The user's wallet account.
/// - `amount_canceled`: The amount to cancel.
/// - `dc_canister`: The principal of the DC canister.
///
/// # Returns
/// A boolean indicating the success of the cancellation.
pub fn cancel_withdrawal(
	token: String,
	chain: String,
	account: String,
	amount_canceled: u64,
	dc_canister: Principal
) -> bool {
	let chain: super::types::Chain = chain.try_into().unwrap();
	let token: super::types::Wallet = token.try_into().unwrap();
	let account: super::types::Wallet = account.try_into().unwrap();

	let hash_key = (token.clone(), chain.clone(), account.clone(), dc_canister.clone());

	// go through the witheld amounts and remove this amount from it
	super::WITHHELD_AMOUNTS.with(|witheld_amounts| {
		let mut mut_witheld_amounts = witheld_amounts.borrow_mut();
		let unwithdrawn_amounts = mut_witheld_amounts
			.get(&hash_key)
			.expect("CANCEL_WITHDRAW_ERROR:AMOUNT_NOT_WITHELD")
			.into_iter()
			.filter(|&amount_to_withdraw| *amount_to_withdraw != amount_canceled)
			.cloned()
			.collect();
		mut_witheld_amounts.insert(hash_key.clone(), unwithdrawn_amounts);
	});

	// go through the witheld balance store and remove this amount from it
	super::WITHHELD_REMITTANCE.with(|withheld_remittance| {
		withheld_remittance
			.borrow_mut()
			.remove(
				&(token.clone(), chain.clone(), account.clone(), dc_canister.clone(), amount_canceled)
			);
	});

	// add the withheld total back to the available balance
	super::REMITTANCE.with(|remittance| {
		if let Some(existing_data) = remittance.borrow_mut().get_mut(&hash_key) {
			existing_data.balance = existing_data.balance + amount_canceled;
		}
	});

	return true;
}

/// Validates remittance data based on whether the caller is a PDC or not.
///
/// # Parameters
/// - `is_pdc`: A boolean indicating if the caller is a PDC.
/// - `new_remittances`: A vector of new remittance data models.
/// - `dc_canister`: The principal of the DC canister.
///
/// # Returns
/// A result indicating success or an error message.
pub fn validate_remittance_data(
	is_pdc: bool,
	new_remittances: &Vec<super::types::DataModel>,
	dc_canister: Principal
) -> Result<(), String> {
	match is_pdc {
		true => validate_pdc_remittance_data(new_remittances, dc_canister),
		false => validate_dc_remittance_data(new_remittances, dc_canister),
	}
}

/// Validates remittance data for processing by a PDC.
///
/// # Parameters
/// - `new_remittances`: A vector of new remittance data models.
/// - `dc_canister`: The principal of the DC canister.
///
/// # Returns
/// A result indicating success or an error message.
pub fn validate_pdc_remittance_data(
	new_remittances: &Vec<super::types::DataModel>,
	dc_canister: Principal
) -> Result<(), String> {
	// validate that all adjust operations lead to a sum of zero
	let adjust_operations: Vec<super::types::DataModel> = new_remittances
		.into_iter()
		.filter(|&single_remittance| single_remittance.action == super::types::Action::Adjust)
		.cloned()
		.collect();
	// apply the same validation of dc canisters to the adjust operations of a pdc canister
	if let Err(err_message) = validate_dc_remittance_data(&adjust_operations, dc_canister) {
		return Err(err_message);
	}

	// validate that all operations that are not "adjust" operations are positive amounts
	// other than adjusts we currently have no use for negative amounts operations
	// this can be later changed
	let non_adjust_operations_gt_0: Vec<&super::types::DataModel> = new_remittances
		.into_iter()
		.filter(|single_remittance| {
			single_remittance.action != super::types::Action::Adjust && single_remittance.amount < 0
		})
		.collect();
	if non_adjust_operations_gt_0.len() > 0 {
		return Err("NON_ADJUST_AMOUNT_MUST_BE_GT_0".to_string());
	}

	Ok(())
}

/// Validates remittance data for processing by a DC canister.
///
/// # Parameters
/// - `new_remittances`: A vector of new remittance data models.
/// - `dc_canister`: The principal of the DC canister.
///
/// # Returns
/// A result indicating success or an error message.
pub fn validate_dc_remittance_data(
	new_remittances: &Vec<super::types::DataModel>,
	dc_canister: Principal
) -> Result<(), String> {
	// validate that all operations are adjust and the resultant of amounts is zero
	let amount_delta = new_remittances.iter().fold(0, |acc, account| acc + account.amount);

	if amount_delta != 0 {
		return Err("SUM_ADJUST_AMOUNTS != 0".to_string());
	}

	// validate it is only adjust action provided
	let is_action_valid = new_remittances
		.iter()
		.all(|item| item.action == super::types::Action::Adjust);

	if !is_action_valid {
		return Err("INVALID_ACTION_FOUND".to_string());
	}

	// check for all the negative deductions and confirm that the owners have at least that much balance
	let mut sufficient_balance_error: Result<(), String> = Ok(());
	new_remittances
		.iter()
		.filter(|&item| item.amount < 0)
		.for_each(|item| {
			let existing_balance = get_available_balance(
				item.token.clone(),
				item.chain.clone(),
				item.account.clone(),
				dc_canister.clone()
			);

			if existing_balance.balance < (item.amount.abs() as u64) {
				sufficient_balance_error = Err("INSUFFICIENT_USER_BALANCE".to_string());
			}
		});
	if let Err(_) = sufficient_balance_error {
		return sufficient_balance_error;
	}
	// check for all positive additions that the canister has enough balance to cover it
	let mut insufficient_canister_balance: Result<(), String> = Ok(());
	new_remittances
		.iter()
		.filter(|&item| item.amount > 0)
		.for_each(|item| {
			let existing_balance = get_canister_balance(
				item.token.clone(),
				item.chain.clone(),
				dc_canister.clone()
			);

			if existing_balance.balance < (item.amount as u64) {
				insufficient_canister_balance = Err("INSUFFICIENT_CANISTER_BALANCE".to_string());
			}
		});

	insufficient_canister_balance
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn test_recover_address_from_eth_signature() {
		let nonce: u64 = 10;
		let amount: u64 = 100;
		let address = "0x5c8e3a7c16fa5cdde9f74751d6b2395176f05c55".to_string();
		let chain_id = "ethereum:5";
		let dc_canister_id = "br5f7-7uaaa-aaaaa-qaaca-cai";
		let token_address = "0x5c8e3a7c16fa5cdde9f74751d6b2395176f05c55";
		let hashed_output = [
			8, 134, 176, 185, 121, 53, 193, 199, 185, 42, 238, 73, 122, 96, 223, 42, 230, 175, 125, 59,
			72, 6, 36, 6, 38, 59, 74, 94, 51, 57, 117, 88,
		].to_vec();

		let recovered_address = hash_remittance_parameters(
			nonce,
			amount,
			&address,
			chain_id,
			dc_canister_id,
			token_address
		);
		assert_eq!(recovered_address, hashed_output);
	}
}