diff --git a/src/orphans/undo_transactions/undo_rewards.rs b/src/orphans/undo_transactions/undo_rewards.rs index 018149f..dc11103 100644 --- a/src/orphans/undo_transactions/undo_rewards.rs +++ b/src/orphans/undo_transactions/undo_rewards.rs @@ -2,7 +2,6 @@ use crate::blocks::rewards::RewardsTransaction; use crate::common::network_paths_and_settings::block_extension_and_paths; use crate::decode; use crate::records::balance_sheet::operations::balance_sheet_operation_with_db; -use crate::records::record_chain::miner_earnings::remove_finalized_miner_earnings; use crate::records::record_chain::rewards_tx::{ remove_immature_reward, remove_reward_credit_marker, reward_credit_applied, }; @@ -42,7 +41,6 @@ pub async fn undo_rewards_transaction( let hash = decode(transaction.unsigned.hash().await).unwrap(); let _ = remove_wallet_transaction_index(db, &[mining_receiver], &hash); - remove_finalized_miner_earnings(db, &hash); // Remove the reward transaction lookup from the txid tree. let tree = db.open_tree("txid").unwrap(); diff --git a/src/records/memory/mempool/selection.rs b/src/records/memory/mempool/selection.rs index 385464e..ad350e7 100644 --- a/src/records/memory/mempool/selection.rs +++ b/src/records/memory/mempool/selection.rs @@ -1,5 +1,4 @@ use super::*; -use crate::records::record_chain::miner_earnings::MinerEarnings; use crate::records::record_chain::pending_effects::{BalanceOperand, PendingEffects}; use crate::records::record_chain::wallet_tx_index::index_wallet_transaction; @@ -348,15 +347,13 @@ pub async fn apply_selected_transaction_math( block_number: u32, start_index: usize, pending_effects: &mut PendingEffects, -) -> Result { +) -> Result<()> { // Net balance deltas are collected first so multiple changes to the same // address/asset pair become one balance-sheet write. let mut balance_changes: HashMap = HashMap::new(); let miner_address = address_key_bytes(db, &miner); let base_coin = BASECOIN.as_bytes().to_vec(); let mut tx_index = start_index; - let mut miner_earnings = MinerEarnings::default(); - for tx in &batch.transactions { // Transaction index is stored with the block number for later txid // lookups inside the saved block payload. @@ -372,9 +369,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected transfer fee")?) - .map_err(|err| anyhow!(err))?; // Transfers move the asset, charge the base fee, and credit // that fee to the miner including this transaction. let transfer_asset = nft_asset_name(coin, *nft_series as u32); @@ -416,9 +410,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected token fee")?) - .map_err(|err| anyhow!(err))?; // Token creation mints the initial supply and records metadata // used by later issue and burn validation. add_balance_change(db, &mut balance_changes, creator, ticker, *number); @@ -486,9 +477,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected issue-token fee")?) - .map_err(|err| anyhow!(err))?; add_balance_change(db, &mut balance_changes, creator, ticker, *number); add_balance_change(db, &mut balance_changes, creator, &BASECOIN, -*fee); add_balance_change_bytes( @@ -528,9 +516,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected burn fee")?) - .map_err(|err| anyhow!(err))?; let burned_asset = nft_asset_name(coin, *nft_series as u32); add_balance_change(db, &mut balance_changes, address, &burned_asset, -*value); add_balance_change(db, &mut balance_changes, address, &BASECOIN, -*fee); @@ -566,9 +551,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected NFT fee")?) - .map_err(|err| anyhow!(err))?; // Series-one NFT creation expands into numbered assets; later // series use the given NFT name as the asset key. if *series == 1 { @@ -639,9 +621,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected marketing fee")?) - .map_err(|err| anyhow!(err))?; add_balance_change(db, &mut balance_changes, advertiser, &BASECOIN, -*fee); add_balance_change_bytes( &mut balance_changes, @@ -669,9 +648,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected vanity fee")?) - .map_err(|err| anyhow!(err))?; // Vanity transactions update the alias registry during the // final block-effect commit so rollback can restore it. pending_effects.update_vanity(address, vanity_address, hash); @@ -711,28 +687,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee1, "selected swap fee1")?) - .map_err(|err| anyhow!(err))?; - miner_earnings - .add_fee(nonnegative_u64(*fee2, "selected swap fee2")?) - .map_err(|err| anyhow!(err))?; - miner_earnings - .add_tip( - ticker1, - u32::try_from(*nft_series1) - .map_err(|_| anyhow!("Selected swap NFT series1 was negative"))?, - nonnegative_u64(*tip1, "selected swap tip1")?, - ) - .map_err(|err| anyhow!(err))?; - miner_earnings - .add_tip( - ticker2, - u32::try_from(*nft_series2) - .map_err(|_| anyhow!("Selected swap NFT series2 was negative"))?, - nonnegative_u64(*tip2, "selected swap tip2")?, - ) - .map_err(|err| anyhow!(err))?; // Swaps debit both sides first, then credit received assets, // miner fees, and optional asset tips. let asset1 = nft_asset_name(ticker1, *nft_series1 as u32); @@ -809,9 +763,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected loan fee")?) - .map_err(|err| anyhow!(err))?; // Loan creation moves the loan asset to the borrower and locks // collateral under a contract-specific holding key. add_balance_change(db, &mut balance_changes, lender, &BASECOIN, -*fee); @@ -881,16 +832,6 @@ pub async fn apply_selected_transaction_math( // Loan payments resolve the contract, then move repayment from // borrower to lender while paying any tip to the miner. let (loan_coin, lender) = resolve_loan_details(db, contract_hash).await?; - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected loan payment fee")?) - .map_err(|err| anyhow!(err))?; - miner_earnings - .add_tip( - &binary_to_string(loan_coin.clone()), - 0, - nonnegative_u64(*tip, "selected loan payment tip")?, - ) - .map_err(|err| anyhow!(err))?; add_balance_change(db, &mut balance_changes, address, &BASECOIN, -*fee); add_balance_change_bytes( &mut balance_changes, @@ -955,9 +896,6 @@ pub async fn apply_selected_transaction_math( hash, .. } => { - miner_earnings - .add_fee(nonnegative_u64(*fee, "selected collateral fee")?) - .map_err(|err| anyhow!(err))?; // Collateral claims release the contract holding to the claimant // and mark the loan as closed. let (collateral, collateral_amount) = @@ -1026,11 +964,7 @@ pub async fn apply_selected_transaction_math( pending_effects.add_balance(&address, change.unsigned_abs(), &coin, operand); } - Ok(miner_earnings) -} - -fn nonnegative_u64(value: i64, field: &str) -> Result { - u64::try_from(value).map_err(|_| anyhow!("{field} cannot be negative")) + Ok(()) } pub async fn clear_selected_transaction_sql( @@ -1044,7 +978,7 @@ pub async fn clear_selected_transaction_sql( // selected batch into the block file afterward. let batch = select_transactions_for_block(limit).await?; let mut pending_effects = PendingEffects::default(); - let _miner_earnings = apply_selected_transaction_math( + apply_selected_transaction_math( &batch, db, miner, diff --git a/src/records/record_chain/mod.rs b/src/records/record_chain/mod.rs index 0ee12f8..c65fbe7 100644 --- a/src/records/record_chain/mod.rs +++ b/src/records/record_chain/mod.rs @@ -8,7 +8,6 @@ pub mod header_number; pub mod issue_token_tx; pub mod lender_tx; pub mod marketing_tx; -pub mod miner_earnings; pub mod nft_provenance; pub mod nft_tx; pub mod parse_transactions; diff --git a/src/records/record_chain/rewards_tx.rs b/src/records/record_chain/rewards_tx.rs index 44c014b..c6de6b2 100644 --- a/src/records/record_chain/rewards_tx.rs +++ b/src/records/record_chain/rewards_tx.rs @@ -5,9 +5,6 @@ use crate::lazy_static; use crate::records::balance_sheet::operations::balance_sheet_operation_with_db; use crate::records::block_height::get_block_height::get_height; use crate::records::memory::mempool::BASECOIN; -use crate::records::record_chain::miner_earnings::{ - earnings_from_transactions, store_finalized_miner_earnings, MinerEarnings, -}; use crate::records::record_chain::pending_effects::PendingEffects; use crate::records::record_chain::wallet_tx_index::index_wallet_transaction_direct; use crate::records::unpack_block::load_by_block_number::load_block; @@ -26,7 +23,6 @@ struct ImmatureReward { amount: u64, txid: Vec, entry_index: u32, - earnings: MinerEarnings, } lazy_static! { @@ -60,8 +56,6 @@ fn mark_reward_credit_applied(db: &Db, block_height: u32) -> Result<(), String> } fn credit_matured_reward(db: &Db, reward: ImmatureReward) -> Result<(), String> { - store_finalized_miner_earnings(db, &reward.txid, &reward.earnings)?; - if reward_credit_applied(db, reward.block_height) { return Ok(()); } @@ -88,7 +82,6 @@ pub async fn record_saved_reward( amount: u64, txid: Vec, entry_index: u32, - earnings: MinerEarnings, ) -> Result<(), String> { let matured = { let mut rewards = IMMATURE_REWARDS.lock().await; @@ -99,7 +92,6 @@ pub async fn record_saved_reward( amount, txid, entry_index, - earnings, }); if rewards.len() > IMMATURE_REWARD_WINDOW { @@ -132,7 +124,6 @@ pub async fn rebuild_immature_reward_window(db: &Db) -> Result<(), String> { Err(_) => continue, }; let miner = block.vrf_block.unmined_block.miner; - let earnings = earnings_from_transactions(db, &block.transactions).await?; for (position, transaction) in block.transactions.into_iter().enumerate() { if let Transaction::Rewards(rewards) = transaction { @@ -146,7 +137,6 @@ pub async fn rebuild_immature_reward_window(db: &Db) -> Result<(), String> { amount: rewards.unsigned.value, txid, entry_index, - earnings: earnings.clone(), }); break; } diff --git a/src/records/record_chain/save.rs b/src/records/record_chain/save.rs index 537fcf4..7af9832 100644 --- a/src/records/record_chain/save.rs +++ b/src/records/record_chain/save.rs @@ -22,7 +22,6 @@ use crate::records::memory::mempool::{ }; use crate::records::memory::network_mapping::NodeInfo; use crate::records::memory::torrent_status::prune_torrent_statuses_through_height; -use crate::records::record_chain::miner_earnings::earnings_from_transactions; use crate::records::record_chain::parse_transactions::handle_transactions; use crate::records::record_chain::pending_effects::PendingEffects; use crate::records::record_chain::previous_difficulty::previous_block_difficulty; @@ -133,8 +132,6 @@ pub async fn save_block(params: SaveBlockParams) -> Result<(), String> { let mut index_counter = 0; let index_mutex = Arc::new(Mutex::new(&mut index_counter)); let mut pending_effects = PendingEffects::default(); - let mut miner_earnings = earnings_from_transactions(&db, &block.transactions).await?; - // Append transaction-derived record data to the block binary while // tracking the index offset where mempool-derived records begin. binary_data = handle_transactions( @@ -173,7 +170,7 @@ pub async fn save_block(params: SaveBlockParams) -> Result<(), String> { .await .map_err(|e| e.to_string())?; - let selected_earnings = apply_selected_transaction_math( + apply_selected_transaction_math( &selected, &db, miner.clone(), @@ -183,7 +180,6 @@ pub async fn save_block(params: SaveBlockParams) -> Result<(), String> { ) .await .map_err(|e| e.to_string())?; - miner_earnings.merge(selected_earnings)?; save_binary_data_with_mempool_stream(SaveBinaryDataWithMempoolStreamParams { data: &binary_data, @@ -230,7 +226,6 @@ pub async fn save_block(params: SaveBlockParams) -> Result<(), String> { amount, txid, entry_index, - miner_earnings, ) .await { diff --git a/src/rpc/commands/address_history.rs b/src/rpc/commands/address_history.rs index ebb9674..f511f82 100644 --- a/src/rpc/commands/address_history.rs +++ b/src/rpc/commands/address_history.rs @@ -1,15 +1,147 @@ +use crate::blocks::loans::LoanContractTransaction; +use crate::common::types::{Transaction, COIN_LENGTH}; +use crate::decode; use crate::records::memory::mempool::latest_pending_txids_by_address; -use crate::records::record_chain::miner_earnings::finalized_miner_earnings_bytes; +use crate::records::memory::mempool::BASECOIN; use crate::records::record_chain::wallet_tx_index::WALLET_TX_INDEX_TREE; +use crate::records::unpack_block::load_by_block_number::load_block; +use crate::rpc::commands::transaction_by_txid::request_transaction_by_txid; use crate::rpc::commands::transaction_by_txid::transaction_bytes_with_block; use crate::rpc::responses::RpcResponse; use crate::sled::Db; use crate::wallets::structures::Wallet; -use std::collections::HashSet; +use std::collections::{BTreeMap, HashSet}; use std::ops::Bound; const TXID_LENGTH: usize = 32; const MAX_ADDRESS_HISTORY_TXIDS: usize = 10_000; +const MINER_EARNING_FEE: u8 = 0; +const MINER_EARNING_TIP: u8 = 1; +const MINER_EARNING_ENTRY_BYTES: usize = 1 + COIN_LENGTH + 4 + 8; + +#[derive(Default)] +struct MinerEarnings { + entries: BTreeMap<(u8, String, u32), u64>, +} + +impl MinerEarnings { + fn add_fee(&mut self, amount: u64) -> Result<(), String> { + self.add(MINER_EARNING_FEE, BASECOIN.clone(), 0, amount) + } + + fn add_tip(&mut self, asset: &str, nft_series: u32, amount: u64) -> Result<(), String> { + self.add(MINER_EARNING_TIP, asset.to_string(), nft_series, amount) + } + + fn add( + &mut self, + earning_type: u8, + asset: String, + nft_series: u32, + amount: u64, + ) -> Result<(), String> { + if amount == 0 { + return Ok(()); + } + if asset.as_bytes().len() != COIN_LENGTH { + return Err(format!( + "Miner earning asset must be exactly {COIN_LENGTH} bytes: {asset:?}" + )); + } + let total = self + .entries + .entry((earning_type, asset, nft_series)) + .or_default(); + *total = total + .checked_add(amount) + .ok_or_else(|| "Miner earnings amount overflowed u64.".to_string())?; + Ok(()) + } + + fn encode(&self) -> Result, String> { + let count = u32::try_from(self.entries.len()) + .map_err(|_| "Miner earnings entry count overflowed u32.".to_string())?; + let mut bytes = + Vec::with_capacity(4 + self.entries.len().saturating_mul(MINER_EARNING_ENTRY_BYTES)); + bytes.extend_from_slice(&count.to_le_bytes()); + for ((earning_type, asset, nft_series), amount) in &self.entries { + bytes.push(*earning_type); + bytes.extend_from_slice(asset.as_bytes()); + bytes.extend_from_slice(&nft_series.to_le_bytes()); + bytes.extend_from_slice(&amount.to_le_bytes()); + } + Ok(bytes) + } +} + +async fn loan_payment_tip_asset(db: &Db, contract_hash: &str) -> Result { + let contract_hash = decode(contract_hash) + .map_err(|err| format!("Failed to decode loan contract hash for miner tip: {err}"))?; + let RpcResponse::Binary(bytes) = request_transaction_by_txid(db, contract_hash).await; + if bytes.is_empty() || bytes[0] != 7 { + return Err("Loan payment miner tip references an invalid loan contract.".to_string()); + } + let loan = LoanContractTransaction::from_bytes(7, &bytes[1..]) + .await + .map_err(|err| format!("Failed to decode loan contract for miner tip: {err}"))?; + Ok(loan.unsigned_loan_contract.loan_coin) +} + +async fn miner_earnings_from_transactions( + db: &Db, + transactions: &[Transaction], +) -> Result { + let mut earnings = MinerEarnings::default(); + + for transaction in transactions { + match transaction { + Transaction::Genesis(_) | Transaction::Rewards(_) => {} + Transaction::Transfer(tx) => earnings.add_fee(tx.unsigned_transfer.txfee)?, + Transaction::Token(tx) => earnings.add_fee(tx.unsigned_create_token.txfee)?, + Transaction::IssueToken(tx) => earnings.add_fee(tx.unsigned_issue_token.txfee)?, + Transaction::Burn(tx) => earnings.add_fee(tx.unsigned_burn.txfee)?, + Transaction::Nft(tx) => earnings.add_fee(tx.unsigned_create_nft.txfee)?, + Transaction::Marketing(tx) => earnings.add_fee(tx.unsigned_marketing.txfee)?, + Transaction::Swap(tx) => { + earnings.add_fee(tx.unsigned_swap.txfee1)?; + earnings.add_fee(tx.unsigned_swap.txfee2)?; + earnings.add_tip( + &tx.unsigned_swap.ticker1, + tx.unsigned_swap.nft_series1, + tx.unsigned_swap.tip1, + )?; + earnings.add_tip( + &tx.unsigned_swap.ticker2, + tx.unsigned_swap.nft_series2, + tx.unsigned_swap.tip2, + )?; + } + Transaction::Lender(tx) => earnings.add_fee(tx.unsigned_loan_contract.txfee)?, + Transaction::Borrower(tx) => { + earnings.add_fee(tx.unsigned_contract_payment.txfee)?; + if tx.unsigned_contract_payment.tip > 0 { + let asset = + loan_payment_tip_asset(db, &tx.unsigned_contract_payment.contract_hash) + .await?; + earnings.add_tip(&asset, 0, tx.unsigned_contract_payment.tip)?; + } + } + Transaction::Collateral(tx) => earnings.add_fee(tx.unsigned_collateral_claim.txfee)?, + Transaction::Vanity(tx) => earnings.add_fee(tx.unsigned_vanity_address.txfee)?, + } + } + + Ok(earnings) +} + +async fn miner_earnings_for_block(db: &Db, block_height: u32) -> Result, String> { + // Reward history is already delayed until maturity. Derive its associated + // fees and tips from the canonical block only when the RPC record is requested. + let block = load_block(block_height).await?; + miner_earnings_from_transactions(db, &block.transactions) + .await? + .encode() +} fn signature_count(transaction_type: u8) -> usize { match transaction_type { @@ -40,7 +172,7 @@ async fn transaction_records_response( match transaction_bytes_with_block(db, txid).await { Ok((block_height, transaction_bytes)) => { let miner_earnings = if transaction_bytes.first() == Some(&1) { - match finalized_miner_earnings_bytes(db, txid) { + match miner_earnings_for_block(db, block_height).await { Ok(bytes) => bytes, Err(err) => { return RpcResponse::Binary(format!("error: {err}").into_bytes()); @@ -75,9 +207,6 @@ async fn transaction_records_response( response.extend_from_slice(&block_height.to_le_bytes()); response.extend_from_slice(&tx_len.to_le_bytes()); response.extend_from_slice(&transaction_bytes); - // Every history record ends with a miner-earnings count. Reward - // records may then include fixed entries of: - // type:u8, asset:[u8;15], nft_series:u32, amount:u64. response.extend_from_slice(&miner_earnings); } @@ -235,3 +364,69 @@ pub async fn latest_transactions(address_bytes: Vec, limit: u32, db: &Db) -> transaction_records_response(&txid_bytes, db, false).await } + +#[cfg(test)] +mod tests { + use super::*; + use crate::blocks::swap::{SwapTransaction, UnsignedSwapTransaction}; + use crate::blocks::token::{CreateTokenTransaction, UnsignedCreateTokenTransaction}; + + #[tokio::test] + async fn derives_fees_and_tips_from_requested_block_transactions() { + let db = sled::Config::new().temporary(true).open().unwrap(); + let token = Transaction::Token(CreateTokenTransaction { + unsigned_create_token: UnsignedCreateTokenTransaction { + txtype: 3, + time: 1, + creator: "creator".to_string(), + ticker: format!("{:<15}", "token"), + number: 1, + hard_limit: 0, + txfee: 500, + }, + signature: String::new(), + }); + let asset_one = format!("{:<15}", "assetone"); + let asset_two = format!("{:<15}", "assettwo"); + let swap = Transaction::Swap(SwapTransaction { + unsigned_swap: UnsignedSwapTransaction { + txtype: 6, + timestamp: 2, + offer_expiration: 3, + ticker1: asset_one.clone(), + nft_series1: 7, + value1: 1, + ticker2: asset_two.clone(), + nft_series2: 0, + value2: 1, + sender1: "sender1".to_string(), + sender2: "sender2".to_string(), + tip1: 11, + tip2: 13, + txfee1: 2, + txfee2: 3, + }, + signature1: String::new(), + signature2: String::new(), + }); + + let earnings = miner_earnings_from_transactions(&db, &[token, swap]) + .await + .unwrap(); + + assert_eq!( + earnings + .entries + .get(&(MINER_EARNING_FEE, BASECOIN.clone(), 0)), + Some(&505) + ); + assert_eq!( + earnings.entries.get(&(MINER_EARNING_TIP, asset_one, 7)), + Some(&11) + ); + assert_eq!( + earnings.entries.get(&(MINER_EARNING_TIP, asset_two, 0)), + Some(&13) + ); + } +}