bip0032 0.1.0

Another Rust implementation of BIP-0032 standard
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# SLIP-0010

This crate provides optional [SLIP-0010](https://github.com/satoshilabs/slips/blob/master/slip-0010.md) support behind the `slip10` feature.
It shares the same [`ExtendedPrivateKey`]/[`ExtendedPublicKey`] structure as [BIP-0032](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki),
but the derivation rules and supported curves differ.

## Supported curves and features

| Curve     | Feature                            | Backends        | Hardened | Non-hardened (private) | Non-hardened (public) | Serialization |
| --------- | ---------------------------------- | --------------- | -------- | ---------------------- | --------------------- | ------------- |
| secp256k1 | `slip10` + (`k256` \| `secp256k1`) | k256, secp256k1 | yes      | yes                    | yes                   | no            |
| nist256p1 | `slip10` + `p256`                  | p256            | yes      | yes                    | yes                   | no            |
| ed25519   | `slip10` + `ed25519-dalek`         | ed25519-dalek   | yes      | no                     | no                    | no            |

Note: SLIP-0010 does not define a standardized extended key serialization.
Only the BIP32 secp256k1 encoding (xpub/xprv) is supported for serialization.

## Usage

Seed material is typically derived from a [BIP-0039](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) mnemonic
(for example, via [bip0039](https://crates.io/crates/bip0039)).

```rust,ignore
use bip0039::{Count, English, Mnemonic};

let mnemonic = <Mnemonic<English>>::generate(Count::Words12);
let seed = mnemonic.to_seed("");
```

The examples below assume the `seed` from above.

### secp256k1 (non-hardened supported)

```rust
use bip0032::{DerivationPath, ExtendedPrivateKey, curve::secp256k1::*};
use bip0032::slip10::{Slip10MasterKey, Slip10NonHardenedDerivation};

# let seed = [0u8; 64];
let master = ExtendedPrivateKey::<Secp256k1Curve<K256Backend>>::new_slip10(&seed).unwrap();
let path: DerivationPath = "m/0H/1".parse().unwrap();
let child = Slip10NonHardenedDerivation::derive_slip10_path(&master, &path).unwrap();
let public = child.public_key().to_bytes();
```

### nist256p1 (non-hardened supported)

```rust
use bip0032::{DerivationPath, ExtendedPrivateKey, curve::nist256p1::*};
use bip0032::slip10::{Slip10MasterKey, Slip10NonHardenedDerivation};

# let seed = [0u8; 64];
let master = ExtendedPrivateKey::<Nist256p1Curve<P256Backend>>::new_slip10(&seed).unwrap();
let path: DerivationPath = "m/0H/1".parse().unwrap();
let child = Slip10NonHardenedDerivation::derive_slip10_path(&master, &path).unwrap();
let public = child.public_key().to_bytes();
```

### ed25519 (hardened only)

```rust
use bip0032::{ExtendedPrivateKey, HardenedDerivationPath, curve::ed25519::*};
use bip0032::slip10::{Slip10HardenedOnlyDerivation, Slip10MasterKey};

# let seed = [0u8; 64];
let master = ExtendedPrivateKey::<Ed25519Curve<Ed25519DalekBackend>>::new_slip10(&seed).unwrap();
let path: HardenedDerivationPath = "m/0H/1H".parse().unwrap();
let child = Slip10HardenedOnlyDerivation::derive_slip10_path(&master, &path).unwrap();
let public = child.public_key().to_bytes();
```

## Notes

- `Slip10NonHardenedDerivation` is implemented for both extended private and
  extended public keys; hardened derivation is only available for private keys.
- Fingerprints are computed using Hash160 over the serialized public key bytes.
- SLIP-0010 Ed25519 public keys are serialized as `0x00 || raw32`. Use
  `ed25519_pubkey_from_slip10_bytes` / `ed25519_pubkey_to_slip10_bytes`
  for conversion.