Prioritization of the leaf crates stabilization and dependency graph about rust-bitcoin

[apoelstra]

Agree with the prioritization and high-level observations. Can you say more about:

• What AsRawTransaction would do? (Maybe this is not the issue for it.)
• What features we'd want from Hash trait ideally. Somewhere I recall we came to a rough consensus that our 1.0 MSRV would be 1.6x or thereabouts.

[Kixunil]

What AsRawTransaction would do?

Effectively a copy of AsTransaction from #2347 with only modification being use of raw types (integers, byte slices) to resolve the dependency loop. It'd be considered an implementation detail and only stay there as long as other crates are unstable. Once stable, the implementation would change and the trait would get removed.

Basically what we want:

// in internals
pub struct TransactionEncoder<'a, T>(TransactionEncoderState<'a, T>);

impl<'a, T: AsRawTransaction> TransactionEncoder<'a, T> {
    pub fn new(transaction: &'a T) -> Self { /* ... */ }
}

impl<'a, T: AsRawTransaction> Encoder for TransactionEncoder<'a, T> { /* ... */ }

// in primitives:

pub fn txid(&self) -> Txid {
    struct Wrapper<'a>(&'a Transaction);
    impl<'a> AsRawTransaction for Wrapper<'a> { /* ...*/ }
    let mut encoder = TransactionEncoder::new(&Wrapper(self));
    let mut engine = sha256::engine();
    while !encoder.encoded_chunk().is_empty() {
        engine.input(encoder.encoded_chunk());
        if !encoder.next() { break }
    }
    Txid(engine.finalize())
}

• What features we'd want from Hash trait ideally. Somewhere I recall we came to a rough consensus that our 1.0 MSRV would be 1.6x or thereabouts.

Allow writing fn to_byte_array(self) -> [u8; Self::LEN], though IIRC it may require the feature that is not even in stable and is somewhat broken in nightly too. (I might be confusing this with something else.) But from what I can observe so far: both GAT and weak dependencies will be a must when fully stable, so 1.65 IIRC. But the leaf crates don't need this. Actually that's what I wanted to mention above and forgot.

[apoelstra]

I think we should try the to_byte_array thing. It doesn't look like it needs GATs, just regular ATs, which have been around for a long time.

The AsRawTransaction thing makes sense, thanks. Though I wonder if we want to make this a permanent part of the API (and have a corresponding Raw type for some other types, notably Block and BlockHeader). It seems like it may be useful in some obscure low-level usecases.

OTOH it would be easy to add (or expose) post-1.0 so this isn't a decision we need to make now.

[Kixunil]

I don't see when it'd be useful. Script is already freely convertible, so only Witness is a bit obscure type. We could do something about that too. I was already thinking of having unsized Witness for zero-copy deserialization however it'd loose the index which is non issue when serializing but can be a problem when accessing.