18399107786

Committed 10 Oct 2025 07:04AM UTC coverage: 58.589% (-1.0%) from 59.571%

Build # 18399107786

Build Type

push

github

Committed by

web-flow

Commit Message

feat: custom db timeout for grpc (#7544)

Description
---
Grpc create transaction calls have a timeout while waiting for a
database write. This timeout is 100ms, and should be sufficient, but can
be too long. This creates a custom config option to make this longer, or
shorter.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Added a configurable timeout for wallet gRPC database write operations
to control how long the system waits before reporting a timeout.
  * Default timeout set to 100 ms; adjustable via wallet configuration.
* Helps avoid premature timeouts on slower systems and permits tighter
responsiveness on faster setups.
* Preset configuration updated to include the new option for easier
setup.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

1138 existing lines in 32 files now uncovered.

66489 of 113484 relevant lines covered (58.59%)

228871.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.53

/base_layer/common_types/src/types/fixed_hash.rs

//  Copyright 2022. The Tari Project
//
//  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
//  following conditions are met:
//
//  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
//  disclaimer.
//
//  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
//  following disclaimer in the documentation and/or other materials provided with the distribution.
//
//  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
//  products derived from this software without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
//  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
//  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
//  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use std::{
    convert::TryFrom,
    fmt::{Display, Formatter},
    ops::{Deref, DerefMut},
};

use borsh::{BorshDeserialize, BorshSerialize};
use digest::{consts::U32, generic_array};
use serde::{Deserialize, Serialize};
use tari_utilities::hex::{Hex, HexError};
use utoipa::ToSchema;

const ZERO_HASH: [u8; FixedHash::byte_size()] = [0u8; FixedHash::byte_size()];

#[derive(thiserror::Error, Debug)]
#[error("Invalid size")]
pub struct FixedHashSizeError;

#[derive(
    Clone,
    Copy,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Debug,
    Default,
    Hash,
    Deserialize,
    Serialize,
    BorshSerialize,
    BorshDeserialize,
    ToSchema,
)]
#[serde(transparent)]
pub struct FixedHash([u8; FixedHash::byte_size()]);

impl FixedHash {
    pub const fn new(hash: [u8; FixedHash::byte_size()]) -> Self {
        Self(hash)
    }

    pub const fn byte_size() -> usize {
        32
    }

    pub const fn zero() -> Self {
        Self(ZERO_HASH)
    }

    pub const fn into_array(self) -> [u8; 32] {
        self.0
    }

    pub fn as_slice(&self) -> &[u8] {
        &self.0
    }
}

impl From<[u8; FixedHash::byte_size()]> for FixedHash {
    fn from(hash: [u8; FixedHash::byte_size()]) -> Self {
        Self(hash)
    }
}

impl TryFrom<Vec<u8>> for FixedHash {
    type Error = FixedHashSizeError;

    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
        TryFrom::try_from(value.as_slice())
    }
}

impl TryFrom<&[u8]> for FixedHash {
    type Error = FixedHashSizeError;

    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
        if bytes.len() != FixedHash::byte_size() {
            return Err(FixedHashSizeError);
        }

        let mut buf = [0u8; FixedHash::byte_size()];
        buf.copy_from_slice(bytes);
        Ok(Self(buf))
    }
}

impl From<generic_array::GenericArray<u8, U32>> for FixedHash {
    fn from(hash: generic_array::GenericArray<u8, U32>) -> Self {
        Self(hash.into())
    }
}

impl PartialEq<[u8]> for FixedHash {
    fn eq(&self, other: &[u8]) -> bool {
        self.0[..].eq(other)
    }
}

impl PartialEq<FixedHash> for [u8] {
    fn eq(&self, other: &FixedHash) -> bool {
        self[..].eq(&other.0)
    }
}

impl PartialEq<Vec<u8>> for FixedHash {
    fn eq(&self, other: &Vec<u8>) -> bool {
        self == other.as_slice()
    }
}
impl PartialEq<FixedHash> for Vec<u8> {
    fn eq(&self, other: &FixedHash) -> bool {
        self == other.as_slice()
    }
}

impl AsRef<[u8]> for FixedHash {
    fn as_ref(&self) -> &[u8] {
        self.as_slice()
    }
}

impl Hex for FixedHash {
    fn from_hex(hex: &str) -> Result<Self, HexError>
    where Self: Sized {
        let hash = <[u8; FixedHash::byte_size()] as Hex>::from_hex(hex)?;
        Ok(Self(hash))
    }

    fn to_hex(&self) -> String {
        self.0.to_hex()
    }
}

impl Deref for FixedHash {
    type Target = [u8; FixedHash::byte_size()];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for FixedHash {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl Display for FixedHash {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        for b in self.0 {
            write!(f, "{b:02x}")?;
        }
        Ok(())
    }
}

1	// Copyright 2022. The Tari Project
2	//
3	// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
4	// following conditions are met:
5	//
6	// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
7	// disclaimer.
8	//
9	// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
10	// following disclaimer in the documentation and/or other materials provided with the distribution.
11	//
12	// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
13	// products derived from this software without specific prior written permission.
14	//
15	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
16	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
18	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
20	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
21	// USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22
23	use std::{
24	convert::TryFrom,
25	fmt::{Display, Formatter},
26	ops::{Deref, DerefMut},
27	};
28
29	use borsh::{BorshDeserialize, BorshSerialize};
30	use digest::{consts::U32, generic_array};
31	use serde::{Deserialize, Serialize};
32	use tari_utilities::hex::{Hex, HexError};
33	use utoipa::ToSchema;
34
35	const ZERO_HASH: [u8; FixedHash::byte_size()] = [0u8; FixedHash::byte_size()];
36
37	#[derive(thiserror::Error, Debug)]
38	#[error("Invalid size")]
39	pub struct FixedHashSizeError;
40
41	#[derive(
42	Clone,
43	Copy,
44	PartialEq,
45	Eq,
46	PartialOrd,
47	Ord,
48	Debug,
49	Default,
50	Hash,
51	Deserialize,
52	Serialize,
53	BorshSerialize,	×
54	BorshDeserialize,	×
55	ToSchema,
56	)]
57	#[serde(transparent)]
58	pub struct FixedHash([u8; FixedHash::byte_size()]);
59
60	impl FixedHash {
61	pub const fn new(hash: [u8; FixedHash::byte_size()]) -> Self {	×
62	Self(hash)	×
63	}	×
64
65	pub const fn byte_size() -> usize {	1,321✔
66	32	1,321✔
67	}	1,321✔
68
69	pub const fn zero() -> Self {	11,434✔
70	Self(ZERO_HASH)	11,434✔
71	}	11,434✔
72
73	pub const fn into_array(self) -> [u8; 32] {	4✔
74	self.0	4✔
75	}	4✔
76
77	pub fn as_slice(&self) -> &[u8] {	30,509✔
78	&self.0	30,509✔
79	}	30,509✔
80	}
81
82	impl From<[u8; FixedHash::byte_size()]> for FixedHash {
83	fn from(hash: [u8; FixedHash::byte_size()]) -> Self {	13,037✔
84	Self(hash)	13,037✔
85	}	13,037✔
86	}
87
88	impl TryFrom<Vec<u8>> for FixedHash {
89	type Error = FixedHashSizeError;
90
91	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {	416✔
92	TryFrom::try_from(value.as_slice())	416✔
93	}	416✔
94	}
95
96	impl TryFrom<&[u8]> for FixedHash {
97	type Error = FixedHashSizeError;
98
99	fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {	544✔
100	if bytes.len() != FixedHash::byte_size() {	544✔
101	return Err(FixedHashSizeError);	×
102	}	544✔
103
104	let mut buf = [0u8; FixedHash::byte_size()];	544✔
105	buf.copy_from_slice(bytes);	544✔
106	Ok(Self(buf))	544✔
107	}	544✔
108	}
109
110	impl From<generic_array::GenericArray<u8, U32>> for FixedHash {
111	fn from(hash: generic_array::GenericArray<u8, U32>) -> Self {	46,233✔
112	Self(hash.into())	46,233✔
113	}	46,233✔
114	}
115
116	impl PartialEq<[u8]> for FixedHash {
UNCOV 117	fn eq(&self, other: &[u8]) -> bool {	×
UNCOV 118	self.0[..].eq(other)	×
UNCOV 119	}	×
120	}
121
122	impl PartialEq<FixedHash> for [u8] {
123	fn eq(&self, other: &FixedHash) -> bool {	×
124	self[..].eq(&other.0)	×
125	}	×
126	}
127
128	impl PartialEq<Vec<u8>> for FixedHash {
UNCOV 129	fn eq(&self, other: &Vec<u8>) -> bool {	×
UNCOV 130	self == other.as_slice()	×
UNCOV 131	}	×
132	}
133	impl PartialEq<FixedHash> for Vec<u8> {
134	fn eq(&self, other: &FixedHash) -> bool {	×
135	self == other.as_slice()	×
136	}	×
137	}
138
139	impl AsRef<[u8]> for FixedHash {
140	fn as_ref(&self) -> &[u8] {	4,316✔
141	self.as_slice()	4,316✔
142	}	4,316✔
143	}
144
145	impl Hex for FixedHash {
146	fn from_hex(hex: &str) -> Result<Self, HexError>	585✔
147	where Self: Sized {	585✔
148	let hash = <[u8; FixedHash::byte_size()] as Hex>::from_hex(hex)?;	585✔
149	Ok(Self(hash))	585✔
150	}	585✔
151
152	fn to_hex(&self) -> String {	123✔
153	self.0.to_hex()	123✔
154	}	123✔
155	}
156
157	impl Deref for FixedHash {
158	type Target = [u8; FixedHash::byte_size()];
159
160	fn deref(&self) -> &Self::Target {	14,894✔
161	&self.0	14,894✔
162	}	14,894✔
163	}
164
165	impl DerefMut for FixedHash {
166	fn deref_mut(&mut self) -> &mut Self::Target {	1✔
167	&mut self.0	1✔
168	}	1✔
169	}
170
171	impl Display for FixedHash {
172	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {	65✔
173	for b in self.0 {	2,145✔
174	write!(f, "{b:02x}")?;	2,080✔
175	}
176	Ok(())	65✔
177	}	65✔
178	}

tari-project / tari / 18399107786

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous