From 1d2b73a9b37c6da3ccdb27f463316c3c649c7ae3 Mon Sep 17 00:00:00 2001 From: Sergey Chystiakov Date: Sun, 11 Oct 2026 23:29:31 +0200 Subject: [PATCH 1/2] fix(orders-accounting): show full order ID in overbid errors --- orders-accounting/src/error.rs | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/orders-accounting/src/error.rs b/orders-accounting/src/error.rs index bcf20e4372..4c73227c01 100644 --- a/orders-accounting/src/error.rs +++ b/orders-accounting/src/error.rs @@ -45,7 +45,7 @@ pub enum Error { InvariantNonzeroGiveBalanceForMissingOrder(OrderId), #[error("Order overflow: `{0}`")] OrderOverflow(OrderId), - #[error("Order `{0}` can provide `{1:?}` amount; but attempted to fill `{2:?}`")] + #[error("Order `{0:x}` can provide `{1:?}` amount; but attempted to fill `{2:?}`")] OrderOverbid(OrderId, Amount, Amount), #[error("Order `{0}` provides amount `{1:?}` that is not enough to fill even a single atom")] OrderUnderbid(OrderId, Amount), @@ -75,3 +75,20 @@ impl From for Error { match value {} } } + +#[cfg(test)] +mod tests { + use common::primitives::H256; + + use super::*; + + #[test] + fn order_overbid_displays_full_order_id() { + let order_id = OrderId::new(H256::repeat_byte(0xab)); + + assert_eq!( + Error::OrderOverbid(order_id, Amount::from_atoms(1), Amount::from_atoms(2)).to_string(), + "Order `abababababababababababababababababababababababababababababababab` can provide `Amount { atoms: 1 }` amount; but attempted to fill `Amount { atoms: 2 }`" + ); + } +} From 65834a46bd72623547ea145565c95a7793eca64d Mon Sep 17 00:00:00 2001 From: Sergey Chystiakov Date: Mon, 12 Oct 2026 12:07:58 +0200 Subject: [PATCH 2/2] feat(orders-accounting): show full order ID in all order-related errors --- orders-accounting/src/error.rs | 68 ++++++++++++++++++++++------------ 1 file changed, 45 insertions(+), 23 deletions(-) diff --git a/orders-accounting/src/error.rs b/orders-accounting/src/error.rs index 4c73227c01..7140a721b8 100644 --- a/orders-accounting/src/error.rs +++ b/orders-accounting/src/error.rs @@ -19,43 +19,43 @@ use common::{chain::OrderId, primitives::Amount}; pub enum Error { #[error("Base accounting error: `{0}`")] AccountingError(#[from] accounting::Error), - #[error("Order already exists: `{0}`")] + #[error("Order already exists: `{0:x}`")] OrderAlreadyExists(OrderId), - #[error("Data for order `{0}` not found")] + #[error("Data for order `{0:x}` not found")] OrderDataNotFound(OrderId), - #[error("Attempt to create an order with zero exchange value `{0}`")] + #[error("Attempt to create an order with zero exchange value `{0:x}`")] OrderWithZeroValue(OrderId), - #[error("Data for order `{0}` not found for undo")] + #[error("Data for order `{0:x}` not found for undo")] InvariantOrderDataNotFoundForUndo(OrderId), - #[error("Ask balance for order `{0}` changed for undo")] + #[error("Ask balance for order `{0:x}` changed for undo")] InvariantOrderAskBalanceChangedForUndo(OrderId), - #[error("Give balance for order `{0}` changed for undo")] + #[error("Give balance for order `{0:x}` changed for undo")] InvariantOrderGiveBalanceChangedForUndo(OrderId), - #[error("Data for order `{0}` still exist on conclude undo")] + #[error("Data for order `{0:x}` still exist on conclude undo")] InvariantOrderDataExistForConcludeUndo(OrderId), - #[error("Data for order `{0}` doesn't exist on freeze undo")] + #[error("Data for order `{0:x}` doesn't exist on freeze undo")] InvariantOrderDataNotExistForFreezeUndo(OrderId), - #[error("Ask balance for order `{0}` still exist on conclude undo")] + #[error("Ask balance for order `{0:x}` still exist on conclude undo")] InvariantOrderAskBalanceExistForConcludeUndo(OrderId), - #[error("Give balance for order `{0}` still exist on conclude undo")] + #[error("Give balance for order `{0:x}` still exist on conclude undo")] InvariantOrderGiveBalanceExistForConcludeUndo(OrderId), - #[error("Ask balance for non-existing order `{0}` is not zero")] + #[error("Ask balance for non-existing order `{0:x}` is not zero")] InvariantNonzeroAskBalanceForMissingOrder(OrderId), - #[error("Give balance for non-existing order `{0}` is not zero")] + #[error("Give balance for non-existing order `{0:x}` is not zero")] InvariantNonzeroGiveBalanceForMissingOrder(OrderId), - #[error("Order overflow: `{0}`")] + #[error("Order overflow: `{0:x}`")] OrderOverflow(OrderId), #[error("Order `{0:x}` can provide `{1:?}` amount; but attempted to fill `{2:?}`")] OrderOverbid(OrderId, Amount, Amount), - #[error("Order `{0}` provides amount `{1:?}` that is not enough to fill even a single atom")] + #[error("Order `{0:x}` provides amount `{1:?}` that is not enough to fill even a single atom")] OrderUnderbid(OrderId, Amount), - #[error("Attempt to conclude non-existing order data `{0}`")] + #[error("Attempt to conclude non-existing order data `{0:x}`")] AttemptedConcludeNonexistingOrderData(OrderId), - #[error("Attempt to freeze non-existing order data `{0}`")] + #[error("Attempt to freeze non-existing order data `{0:x}`")] AttemptedFreezeNonexistingOrderData(OrderId), - #[error("Attempt to freeze already frozen order `{0}`")] + #[error("Attempt to freeze already frozen order `{0:x}`")] AttemptedFreezeAlreadyFrozenOrder(OrderId), - #[error("Attempt to fill frozen order `{0}`")] + #[error("Attempt to fill frozen order `{0:x}`")] AttemptedFillFrozenOrder(OrderId), #[error("Unsupported token version")] UnsupportedTokenVersion, @@ -83,12 +83,34 @@ mod tests { use super::*; #[test] - fn order_overbid_displays_full_order_id() { + fn order_errors_display_full_order_id() { let order_id = OrderId::new(H256::repeat_byte(0xab)); + let full_order_id = "abababababababababababababababababababababababababababababababab"; - assert_eq!( - Error::OrderOverbid(order_id, Amount::from_atoms(1), Amount::from_atoms(2)).to_string(), - "Order `abababababababababababababababababababababababababababababababab` can provide `Amount { atoms: 1 }` amount; but attempted to fill `Amount { atoms: 2 }`" - ); + let errors = [ + Error::OrderAlreadyExists(order_id), + Error::OrderDataNotFound(order_id), + Error::OrderWithZeroValue(order_id), + Error::InvariantOrderDataNotFoundForUndo(order_id), + Error::InvariantOrderAskBalanceChangedForUndo(order_id), + Error::InvariantOrderGiveBalanceChangedForUndo(order_id), + Error::InvariantOrderDataExistForConcludeUndo(order_id), + Error::InvariantOrderDataNotExistForFreezeUndo(order_id), + Error::InvariantOrderAskBalanceExistForConcludeUndo(order_id), + Error::InvariantOrderGiveBalanceExistForConcludeUndo(order_id), + Error::InvariantNonzeroAskBalanceForMissingOrder(order_id), + Error::InvariantNonzeroGiveBalanceForMissingOrder(order_id), + Error::OrderOverflow(order_id), + Error::OrderOverbid(order_id, Amount::from_atoms(1), Amount::from_atoms(2)), + Error::OrderUnderbid(order_id, Amount::from_atoms(1)), + Error::AttemptedConcludeNonexistingOrderData(order_id), + Error::AttemptedFreezeNonexistingOrderData(order_id), + Error::AttemptedFreezeAlreadyFrozenOrder(order_id), + Error::AttemptedFillFrozenOrder(order_id), + ]; + + for error in errors { + assert!(error.to_string().contains(full_order_id)); + } } }