Struct MempoolBlockAnchorer 

pub struct MempoolBlockAnchorer<M: MempoolLookup + MempoolBroadcast + Send + Sync> { /* private fields */ }

A BlockAnchorer implementing both sides over a transport that can look up UTXOs (MempoolLookup) and broadcast transactions (MempoolBroadcast). Generic over that transport so a fixture drives it in tests and MempoolHttpClient drives it in production — without changing the logic.

• verify re-derives the expected taproot address from the anchor’s portable proof (pubkey + state_strings) via bt_address, rejects a forged address, then walks the trail back from the anchor’s outpoint (verify_anchor_report): every mark must exist, carry the key its prefix of states derives and spend the mark before it. No pod trust required, and an anchor stays verifiable after later marks spend it.

This anchorer serves the MRC20 trails a pod has already issued (their marks and states stay as they are); new trails use GitmarkAnchorer.

• anchor (Phase 4) loads the named trail from storage, appends an MRC20 state notarising state_hash (via anchor_state, broadcasts the anchoring tx, persists the updated trail, and returns the BlockTrailAnchor (txid/vout/address/state_strings/pubkey). It requires a storage handle (set via MempoolBlockAnchorer::with_storage); the verify-only constructor MempoolBlockAnchorer::new leaves it None and anchor() then errors with a clear message.

Implementations

impl<M: MempoolLookup + MempoolBroadcast + Send + Sync> MempoolBlockAnchorer<M>

pub fn new(lookup: M) -> Self

Wrap a transport as a verify-capable BlockAnchorer. anchor() is unavailable (no storage) and returns an error explaining that with_storage is required.

pub fn with_storage(lookup: M, storage: Arc<dyn Storage>) -> Self

Wrap a transport + pod storage as a fully-capable BlockAnchorer (both verify and anchor). The storage backs the trail load/save at /.well-known/token/{ticker}.json.

pub fn lookup(&self) -> &M

Borrow the underlying transport (e.g. for a one-off address_utxos).

impl<M: MempoolLookup + MempoolBroadcast + Send + Sync> MempoolBlockAnchorer<M>

pub async fn verify_report( &self, anchor: &BlockTrailAnchor, ) -> Result<Option<TrailReport>, ProvenanceError>

The per-link report behind BlockAnchorer::verify: None when the anchor carries no portable proof or its recorded address is not the derivation; otherwise every mark, walked back from the anchor’s outpoint, with the TrailVerdict (verified once every mark is confirmed).

Trait Implementations

impl<M: MempoolLookup + MempoolBroadcast + Send + Sync> BlockAnchorer for MempoolBlockAnchorer<M>

fn anchor<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ticker: &'life1 str, state_hash: &'life2 str, network: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<BlockTrailAnchor, ProvenanceError>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Append one MRC20 state anchoring state_hash under ticker, build + broadcast the anchoring tx, persist the updated trail, and return the produced BlockTrailAnchor. This is the expensive-tier write the provenance design hinges on (ADR-059 §2.2, master-plan Phase 4).

network is honoured as a guard: it must match the trail’s own network (the trail’s chained-key addresses are network-bound). The returned anchor’s vout is 0 (the anchoring tx pays the next chained-key UTXO at output 0); blockheight is None until the tx confirms.

fn verify<'life0, 'life1, 'async_trait>( &'life0 self, anchor: &'life1 BlockTrailAnchor, ) -> Pin<Box<dyn Future<Output = Result<bool, ProvenanceError>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Verify a previously-produced anchor against the chain / fixtures: re-derive the taproot address from the portable proof, then walk the trail back from the anchor’s outpoint, checking that every mark exists, carries the key its states derive and spends the one before it.

impl<M: Clone + MempoolLookup + MempoolBroadcast + Send + Sync> Clone for MempoolBlockAnchorer<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.