Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
41 commits
Select commit Hold shift + click to select a range
cc7b73c
fix(wallet): authenticate pending spends and InstantLock evidence
lklimek Nov 5, 2026
f7bb4ba
fix(spv): defer InstantLocks missing their signing quorum
lklimek Nov 5, 2026
2e3a1a7
test(wallet): retain authorization coverage for witness data
lklimek Nov 5, 2026
32cfbe8
fix(spv): bind verified InstantLocks to their source network
lklimek Nov 5, 2026
285d3ea
chore: merge current dev into wallet authorization prerequisite
lklimek Nov 5, 2026
fa3c85a
Merge remote-tracking branch 'origin/dev' into pr1336-wallet-restore-…
lklimek Nov 6, 2026
493f66b
test(key-wallet): pin that the SIGHASH_SINGLE bug digest never author…
lklimek Nov 6, 2026
a487959
test(dash-spv): reproduce a forged InstantLock shadowing the genuine …
lklimek Nov 6, 2026
8f75a8a
feat(dashcore-crypto): add `BlsSecretKey::sign_digest`
lklimek Nov 6, 2026
bbb7a81
fix(dash-spv): classify InstantLocks once for live and replay
lklimek Nov 6, 2026
6770c57
test(dash-spv): assert the mempool's InstantLock contract exactly
lklimek Nov 6, 2026
fc7c703
test(key-wallet): authorize what the wallet signer produces
lklimek Nov 6, 2026
c90478d
docs(dash-spv): document the InstantLockReceived validation contract
lklimek Nov 6, 2026
0d4a6a8
fix(dash-spv): bind verified InstantLock evidence to the wallet network
lklimek Nov 6, 2026
66d3833
fix(dash-spv): leave Syncing when a verified lock drains the pending …
lklimek Nov 6, 2026
eeb42f9
test(dash-spv): cover refuted and superseded locks on the replay path
lklimek Nov 6, 2026
e5387dd
fix(dash-spv): sign `InstantLockFixture` with a random key
lklimek Nov 6, 2026
5ac610e
refactor(dash-spv): let the engine own InstantLock cycle eligibility
lklimek Nov 6, 2026
357029f
fix(dash-spv): bound InstantLock inputs and dedupe pending locks by hash
lklimek Nov 6, 2026
3f3d330
refactor(dash-spv)!: carry `VerifiedInstantLock` in `InstantLockRecei…
lklimek Nov 6, 2026
9bf93c1
refactor(dash-spv): drop the superseded `InstantLockValidator` impl
lklimek Nov 6, 2026
ae2218d
test(dash-spv): drop an InstantLock above the input bound before queu…
lklimek Nov 6, 2026
38823cd
test(dash-spv): check devnet cycle completeness without the global ov…
lklimek Nov 6, 2026
8b1e686
fix(dash-spv): reject a malformed InstantLock before hashing it
lklimek Nov 6, 2026
18c8d78
refactor(dash-spv): drop the unused `rotated_quorums_of_cycle` query
lklimek Nov 6, 2026
6f206d4
test(dash-spv): import test types instead of writing full paths
lklimek Nov 6, 2026
20bccb1
test(key-wallet): bind each input to its own funding output
lklimek Nov 10, 2026
94fb8b5
test(dash-spv): reproduce unverified locks evicting a verified one
lklimek Nov 10, 2026
1e960df
fix(dash-spv): cache only verified InstantLock txids
lklimek Nov 10, 2026
8137008
refactor(dash-spv): import types and narrow `InstantLockValidator`
lklimek Nov 10, 2026
85d97ca
Merge remote-tracking branch 'origin/dev' into merge/pr1336-dev
lklimek Nov 16, 2026
a182887
test(dash-spv): adapt tests merged from `dev` to verified locks
lklimek Nov 16, 2026
514b9fc
refactor: hash InstantLocks with `InstantLock::hash`
lklimek Nov 16, 2026
2b7cbd8
refactor(key-wallet): move spend authorization to its own PR
lklimek Nov 16, 2026
f1237a6
test(dash-spv): reach the uncertain broadcast state by its timeout
lklimek Nov 16, 2026
3ccc21a
fix(dash-spv): reject InstantLocks that repeat an input
lklimek Nov 16, 2026
358abcc
feat(dashcore): list the inputs an InstantLock of a transaction carries
lklimek Nov 16, 2026
18f5471
fix(dash-spv): bind a withdrawal's lock to its synthetic input
lklimek Nov 16, 2026
bd7021c
fix(dash-spv): keep a foreign-type cycle open for merging
lklimek Nov 16, 2026
b75d212
refactor(dashcore): serialize the withdrawal request as Core does
lklimek Nov 16, 2026
1818275
test(dash-spv): check a foreign-type cycle without hand-set state
lklimek Nov 16, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
31 changes: 31 additions & 0 deletions crypto/src/bls.rs
Original file line number Diff line number Diff line change
Expand Up @@ -311,6 +311,20 @@ impl BlsSecretKey<'_> {
}
}

/// Signs a 32-byte message digest, written under the scheme.
///
/// # Errors
///
/// Returns `InvalidSecretKey` when the bytes are not a valid scalar.
pub fn sign_digest(self, digest: &[u8; 32]) -> Result<BlsSigBytes, BlsError> {
let signature = match self.scheme {
BlsScheme::Legacy => self.scalar::<BlsScChia>()?.sign_digest(digest).to_bytes(),
BlsScheme::Modern => self.scalar::<BlsScIetf>()?.sign_digest(digest).to_bytes(),
};

Ok(BlsSigBytes::from_bytes(signature))
}

fn scalar<S: PkcScheme>(self) -> Result<PkcSecretKey<S>, BlsError> {
PkcSecretKey::<S>::from_bytes(self.bytes.as_bytes()).map_err(|_| BlsError::InvalidSecretKey)
}
Expand Down Expand Up @@ -571,6 +585,23 @@ mod tests {
assert_eq!(signature.is_valid(), valid);
}

#[test]
fn a_digest_signature_verifies_against_its_key_and_digest() {
let secret = BlsSkBytes::from_bytes([1; BLS_SK_LEN]);
for scheme in [BlsScheme::Modern, BlsScheme::Legacy] {
let key = secret.as_scheme(scheme);
let signature = key.sign_digest(&CHAINLOCK_BLOCK_HASH).unwrap();
let public_key = key.public_key().unwrap().as_scheme(scheme);
assert!(public_key.verify(&CHAINLOCK_BLOCK_HASH, &signature).is_ok());
assert!(public_key.verify(&[0; 32], &signature).is_err());
}
let invalid = BlsSkBytes::from_bytes([0xff; BLS_SK_LEN]);
assert_eq!(
invalid.as_scheme(BlsScheme::Modern).sign_digest(&[0; 32]),
Err(BlsError::InvalidSecretKey)
);
}

#[test]
fn test_legacy_format_detection() {
// Test the ability to detect and handle legacy format keys
Expand Down
4 changes: 2 additions & 2 deletions dash-spv/ARCHITECTURE.md
Original file line number Diff line number Diff line change
Expand Up @@ -1112,7 +1112,7 @@ sync/<manager>/

- Listens for InstantLock messages from network
- Validates signatures
- Emits `InstantLockReceived` events
- Emits `InstantLockReceived` events carrying a `VerifiedInstantLock`; locks awaiting quorum data are queued without an event

##### `src/sync/mempool/` - Mempool Transaction Tracking

Expand Down Expand Up @@ -1174,7 +1174,7 @@ The `seen_txids` map provides a 180-second deduplication window to handle the ca
|-------|--------|
| `SyncComplete` | Activate mempool relay on all connected peers (transitions to `Synced`) |
| `BlockProcessed` | Remove confirmed txids from mempool state; immediately rebuild bloom filter if new addresses |
| `InstantLockReceived` | Mark transaction as IS-locked, or store in pending_is_locks if TX not yet received |
| `InstantLockReceived` | Mark transaction as IS-locked, or store in pending_is_locks if TX not yet received. The event carries only verified locks |
| `PeerConnected` | Activate on new peer immediately if already synced |
| `PeerDisconnected` | Remove peer; redistribute its queued txids to a random activated peer |
| `PeersUpdated` with no addresses | All peers lost: call `stop_sync()`, transition to `WaitingForConnections` |
Expand Down
22 changes: 21 additions & 1 deletion dash-spv/src/client/queries.rs
Original file line number Diff line number Diff line change
Expand Up @@ -10,12 +10,14 @@ use crate::error::{Result, SpvError};
use crate::network::NetworkManager;
use crate::sml_engine::MasternodeListEngine;
use crate::storage::PersistentBlockHeaderStorage;
use crate::validation::{InstantLockVerificationError, VerifiedInstantLock};
use dashcore::sml::llmq_type::LLMQType;
use dashcore::sml::masternode_list::MasternodeList;
use dashcore::sml::quorum_entry::qualified_quorum_entry::QualifiedQuorumEntry;
use dashcore::transaction::special_transaction::coinbase::CoinbasePayload;
use dashcore::QuorumHash;
use dashcore::{InstantLock, QuorumHash};
use key_wallet_manager::WalletInterface;
use std::result;
use std::sync::Arc;
use tokio::sync::RwLock;

Expand Down Expand Up @@ -43,6 +45,24 @@ impl<W: WalletInterface, N: NetworkManager> DashSpvClient<W, N> {
}
}

/// Authenticates a lock using the client's synchronized quorum state.
///
/// Returns `None` while the masternode engine or the lock's quorum is unavailable.
/// Malformed locks, and signatures a complete cycle of quorums refutes, return an
/// error. No network request or wallet mutation is made; callers may retry after
/// masternode sync advances.
/// Fetch this evidence before acquiring wallet or persistence write locks.
pub async fn verify_instant_lock(
&self,
instant_lock: &InstantLock,
) -> result::Result<Option<VerifiedInstantLock>, InstantLockVerificationError> {
let Some(engine) = &self.masternode_engine else {
return VerifiedInstantLock::verify::<PersistentBlockHeaderStorage>(instant_lock, None);
};
let engine = engine.read().await;
VerifiedInstantLock::verify(instant_lock, Some(&*engine))
}

/// The newest masternode list, `None` while masternode sync is off or has
/// not built a list yet.
pub async fn latest_masternode_list(&self) -> Option<MasternodeList> {
Expand Down
1 change: 1 addition & 0 deletions dash-spv/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -93,6 +93,7 @@ pub use sync::{
};
pub use tracing::level_filters::LevelFilter;
pub use types::{FilterMatch, ValidationMode};
pub use validation::{InstantLockVerificationError, VerifiedInstantLock};

// Re-export commonly used dashcore types
pub use dashcore::{Address, BlockHash, Network, OutPoint, QuorumHash, ScriptBuf};
Expand Down
4 changes: 1 addition & 3 deletions dash-spv/src/network/costs.rs
Original file line number Diff line number Diff line change
Expand Up @@ -90,9 +90,7 @@ impl Reply {
NetworkMessage::CFHeaders(m) => Reply::CfHeaders(m.stop_hash),
NetworkMessage::Block(block) => Reply::Block(block.block_hash()),
NetworkMessage::Tx(tx) => Reply::Tx(tx.txid()),
NetworkMessage::ISLock(lock) => Reply::InstantLock(InstantSendLockHash::from_raw_hash(
sha256d::Hash::hash(&encode::serialize(lock)),
)),
NetworkMessage::ISLock(lock) => Reply::InstantLock(lock.hash()),
NetworkMessage::CLSig(lock) => Reply::ChainLock(ChainLockHash::from_raw_hash(
sha256d::Hash::hash(&encode::serialize(lock)),
)),
Expand Down
125 changes: 109 additions & 16 deletions dash-spv/src/sml_engine.rs
Original file line number Diff line number Diff line change
Expand Up @@ -56,6 +56,48 @@ impl QRInfoFeedResult {
}
}

/// A stored cycle whose quorums may sign this network's InstantSend locks.
#[derive(Clone, Copy, Debug)]
pub(crate) struct InstantSendCycle<'a> {
/// The cycle's quorums, by quorum index.
pub(crate) quorums: &'a BTreeMap<u16, QualifiedQuorumEntry>,
/// Whether no later QRInfo can replace the cycle's quorums, so it can refute a lock.
pub(crate) complete: bool,
}

/// `true` when the cycle holds a `Verified` quorum of `isd_type` for every active slot.
fn fills_every_slot(quorums: &BTreeMap<u16, QualifiedQuorumEntry>, isd_type: LLMQType) -> bool {
quorums.len() == isd_type.active_quorum_count() as usize
&& quorums.values().all(|quorum| {
quorum.verified == LLMQEntryVerificationStatus::Verified
&& quorum.quorum_entry.llmq_type == isd_type
})
}

/// Whether a stored cycle is complete, or `None` when one of its quorums is unverified or
/// cannot sign IS locks: of type `isd_type`, or any rotating type when `reads_served_type`.
/// Storage stops merging into a cycle only once it fills every slot of `isd_type`.
fn instant_send_cycle_completeness(
quorums: &BTreeMap<u16, QualifiedQuorumEntry>,
isd_type: LLMQType,
reads_served_type: bool,
) -> Option<bool> {
let signs = |llmq_type: LLMQType| {
if reads_served_type {
llmq_type.is_rotating_quorum_type()
} else {
llmq_type == isd_type
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
}
};
if quorums.values().any(|quorum| {
quorum.verified != LLMQEntryVerificationStatus::Verified
|| !signs(quorum.quorum_entry.llmq_type)
}) {
return None;
}
Some(fills_every_slot(quorums, isd_type))
}

/// Why the engine did not take a diff or a QRInfo.
#[derive(Debug, thiserror::Error)]
pub enum FeedError<E> {
Expand Down Expand Up @@ -391,12 +433,31 @@ impl<H: BlockHeaderStorage> MasternodeListEngine<H> {
self.masternode_lists.last_key_value().map(|(_, list)| list)
}

/// The rotated quorums of the cycle `cycle_hash`, by quorum index.
pub fn rotated_quorums_of_cycle(
/// The cycle `cycle_hash` when every quorum of it is verified and of a type that
/// signs this network's InstantSend locks.
pub(crate) fn instant_send_cycle(
&self,
cycle_hash: &BlockHash,
) -> Option<&BTreeMap<u16, QualifiedQuorumEntry>> {
self.rotated_quorums_per_cycle.get(cycle_hash)
) -> Option<InstantSendCycle<'_>> {
let quorums = self.rotated_quorums_per_cycle.get(cycle_hash)?;
let complete = instant_send_cycle_completeness(
quorums,
self.network.isd_llmq_type(),
self.reads_served_rotation_type(),
)?;
Some(InstantSendCycle {
quorums,
complete,
})
}

#[cfg(feature = "test-utils")]
pub(crate) fn install_test_instant_lock_cycle(
&mut self,
cycle: BlockHash,
quorums: BTreeMap<u16, QualifiedQuorumEntry>,
) {
self.rotated_quorums_per_cycle.insert(cycle, quorums);
}

#[cfg(any(test, feature = "test-utils"))]
Expand Down Expand Up @@ -702,14 +763,14 @@ impl<H: BlockHeaderStorage> MasternodeListEngine<H> {
Ok(())
}

/// `true` when the stored cycle has a `Verified` quorum for every active
/// slot. A partial cycle stays open so a later QRInfo can complete it.
/// `true` when the stored cycle has a `Verified` quorum of the configured type for
/// every active slot. A partial or foreign-type cycle stays open so a later QRInfo
/// can complete it.
fn is_cycle_fully_verified(&self, cycle_hash: &BlockHash) -> bool {
let expected = self.network.isd_llmq_type().active_quorum_count() as usize;
self.rotated_quorums_per_cycle.get(cycle_hash).is_some_and(|existing| {
existing.len() == expected
&& existing.values().all(|q| q.verified == LLMQEntryVerificationStatus::Verified)
})
let isd_type = self.network.isd_llmq_type();
self.rotated_quorums_per_cycle
.get(cycle_hash)
.is_some_and(|existing| fills_every_slot(existing, isd_type))
Comment thread
lklimek marked this conversation as resolved.
Resolved
}

/// Keeps the restored cycles whose quorums are all `Verified` and held by
Expand Down Expand Up @@ -799,7 +860,7 @@ impl<H: BlockHeaderStorage> MasternodeListEngine<H> {
/// rotating type the peer serves.
fn rotation_quorum_type(&self, served: &[QuorumEntry]) -> LLMQType {
let configured = self.network.isd_llmq_type();
if self.network != Network::Devnet || devnet_isd_type_override().is_some() {
if !self.reads_served_rotation_type() {
return configured;
}
served
Expand All @@ -809,6 +870,10 @@ impl<H: BlockHeaderStorage> MasternodeListEngine<H> {
.unwrap_or(configured)
}

fn reads_served_rotation_type(&self) -> bool {
self.network == Network::Devnet && devnet_isd_type_override().is_none()
}

/// The hash of the newest cycle base in an active set. A failed DKG leaves
/// an older cycle's quorum at its index, so a set can span cycles, and the
/// newest one is the cycle the set is active for.
Expand Down Expand Up @@ -1135,7 +1200,7 @@ pub(crate) mod test_support {
use dashcore::consensus::deserialize;
use dashcore::hash_types::QuorumVVecHash;
use dashcore::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
use dashcore::ProTxHash;
use dashcore::{InstantLock, ProTxHash};

pub(crate) type TestEngine = MasternodeListEngine<MockHeaderStorage>;

Expand Down Expand Up @@ -1171,6 +1236,11 @@ pub(crate) mod test_support {
block_hashes.into_iter().map(|(height, block_hash)| (block_hash, height)).collect()
}

/// An IS lock of the mainnet fixture's cycle, signed by its quorum at index 23.
pub(crate) fn mainnet_fixture_is_lock() -> InstantLock {
deserialize(&hex_conservative::decode_to_vec("01018d53e7997ead57409750942af0d5e0aafc06f852a9a52308f4781b6a8220298f00000000c6f9d8c63dd15937ea70aaddb7890daad42c91bf6818e2bf76d183d6f2d9215b4b5f84978fad9dde7ab52bdcc0674be891e9029cc1ef0cb01200000000000000a27c98836c4c04653ab81eb4e07ddfc2c8c2c1036b75247969c05a4f25451cd78913a971f1899d9f2bddec9cf8e0104004f72f20c2856453e5aa3bcd2a8200670ec28feda38f67cc400fc72ef1966956656ec0765478c9d16e9a9e470c07f9ed").unwrap()).unwrap()
}

/// A commitment with one signer and zeroed keys and signatures.
pub(crate) fn quorum_entry(
llmq_type: LLMQType,
Expand Down Expand Up @@ -1396,9 +1466,11 @@ pub(crate) mod test_support {

#[cfg(test)]
mod tests {
use super::build_cycle_quorum_map;
use super::test_support::{fixture_heights, quorum_entry, TestEngine};
use super::valid_coinbase_chain_lock;
use super::test_support::{fixture_heights, mainnet_fixture_is_lock, quorum_entry, TestEngine};
use super::{
build_cycle_quorum_map, fills_every_slot, instant_send_cycle_completeness,
valid_coinbase_chain_lock,
};
use super::{FeedError, MasternodeListEngine, QRInfoFeedResult};
use crate::error::{StorageError, StorageResult};
use crate::storage::{BlockHeaderStorage, BlockHeaderTip};
Expand Down Expand Up @@ -3312,4 +3384,25 @@ mod tests {
restored.coinbase_chain_locks.get(&tip_height)
);
}

/// On a devnet the signing cycle can be of another rotating type than the configured
/// one. Holding as many quorums as the configured type has slots does not complete
/// it, so a lock it does not verify is deferred and a later QRInfo still merges in.
#[test]
fn should_not_complete_a_devnet_cycle_of_another_rotating_type() {
let lock = mainnet_fixture_is_lock();
let cycle =
TestEngine::mainnet_fixture().rotated_quorums_per_cycle[&lock.cyclehash].clone();
let served = LLMQType::Llmqtype60_75;
let configured = LLMQType::LlmqtypeDevnetDIP0024;
let slots = configured.active_quorum_count() as usize;
assert!(slots < cycle.len(), "the mainnet cycle has more slots than a devnet one");
let partial: BTreeMap<_, _> = cycle.clone().into_iter().take(slots).collect();

assert!(!fills_every_slot(&partial, configured));

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

✨ Suggestion, not blocking · Testing · Moderate

Devnet storage-gate regression test no longer exercises is_cycle_fully_verified

Why: The PR deleted store_cycle_if_fully_verified_merges_over_a_foreign_type. Its replacement only calls the helper fills_every_slot and instant_send_cycle_completeness. Reverting is_cycle_fully_verified to the old len() == expected && all Verified check would not fail any test.

How to fix it, why, 3 places read, and 2 other checks

How to fix it
Put back an engine-level test that stores a same-size cycle of another rotating type. Check that store_cycle_if_fully_verified still merges the configured type's full set into it. Alternatively, assert engine.is_cycle_fully_verified(&key) is false for that cycle.

Why it matters
A foreign-type cycle could then close the storage gate early again without any test noticing. The PR description lists this case as a regression test that fails on the old code.

Checked in the code
On the commented line: The new assertion assert!(!fills_every_slot(&partial, configured)) calls the helper directly and never reaches is_cycle_fully_verified or store_cycle_if_…

is_cycle_fully_verified now calls fills_every_slot(existing, isd_type).

/// can complete it.
fn is_cycle_fully_verified(&self, cycle_hash: &BlockHash) -> bool {
let isd_type = self.network.isd_llmq_type();
self.rotated_quorums_per_cycle
.get(cycle_hash)

The hunk deletes store_cycle_if_fully_verified_merges_over_a_foreign_type, the only test that ran store_cycle_if_fully_verified with a cycle of another type

/// The storage gate must short-circuit with `Ok(None)` (and not write)
/// when any input entry is not `Verified` or the target cycle is already
/// fully `Verified`, and it only ever merges into a stored cycle.
#[tokio::test]

  • The removed test exercised store_cycle_if_fully_verified against a stored foreign-type cycle.
  • dash-spv/src/sml_engine.rs store_cycle_if_fully_verified_short_circuits only stores cycles of the configured type, so it does not cover the type check
  • Create an issue for this

assert_eq!(instant_send_cycle_completeness(&partial, configured, true), Some(false));
assert_eq!(instant_send_cycle_completeness(&partial, configured, false), None);
assert_eq!(instant_send_cycle_completeness(&cycle, served, false), Some(true));
assert_eq!(instant_send_cycle_completeness(&partial, served, false), Some(false));
}
}
20 changes: 8 additions & 12 deletions dash-spv/src/sync/events.rs
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@
use crate::sml_engine::QRInfoFeedResult;
use crate::sync::mempool::BroadcastResult;
use crate::sync::ManagerIdentifier;
use crate::validation::VerifiedInstantLock;
use dashcore::ephemerealdata::chain_lock::ChainLock;
use dashcore::ephemerealdata::instant_lock::InstantLock;
use dashcore::{BlockHash, ScriptBuf, Txid};
use key_wallet_manager::{FilterMatchKey, WalletId};
use std::collections::{BTreeMap, BTreeSet};
Expand Down Expand Up @@ -153,15 +153,16 @@ pub enum SyncEvent {
validated: bool,
},

/// InstantSend lock received and processed.
/// InstantSend lock verified against its signing quorum.
///
/// A lock awaiting quorum data emits this event once it verifies. Malformed
/// locks and locks a complete, verified cycle refutes emit no event.
///
/// Emitted by: `InstantSendManager`
/// Consumed by: External listeners, mempool state updates
InstantLockReceived {
/// The complete InstantLock data
instant_lock: InstantLock,
/// Whether the BLS signature was validated
validated: bool,
/// The verified lock
instant_lock: VerifiedInstantLock,
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
},

/// The network-level outcome of a self-broadcast transaction was
Expand Down Expand Up @@ -284,12 +285,7 @@ impl fmt::Display for SyncEvent {
),
SyncEvent::InstantLockReceived {
instant_lock,
validated,
} => write!(
f,
"InstantLockReceived(txid={}, validated={})",
instant_lock.txid, validated
),
} => write!(f, "InstantLockReceived(txid={})", instant_lock.txid()),
SyncEvent::TransactionBroadcastResult {
txid,
result,
Expand Down
Loading
Loading