How to generate addresses from an ElectrumMnemonic?

[underctrl]

Hello. I need to 1) test seed phrases to see if they are an Electrum-supported seed phrase or not, and 2) if a seed phrase is a valid Electrum mnemonic, generate addresses for it...

I've been playing around with this library today, trying to guess how I might achieve these two goals, and I've solved the first one... I'm doing this below, and I see that new ElectrumMnemonic() throws an exception when I pass it an invalid seed phrase, so I can just use a try...catch to know when it fails...

var seedPhrase =        "clock unusual snake renew security believe arrow give wish snack turn height";
var seedPhraseInvalid = "clock unusual snake renew security believe arrow give wish snack turn fit";

var eMnemonic1 = new ElectrumMnemonic(seedPhrase);
var eMnemonic2 = new ElectrumMnemonic(seedPhraseInvalid); // throws an exception

However, I can't seem to figure out how to generate addresses for the valid seed phrase above... I generated that seed phrase with Electrum itself, and these are the first three addresses it displays in its UI:

bc1q4decsuzhu94y5cfhvhuvszwfpl9e823vcd77wz
bc1qr35etymn3dhvw8usnf2p0mwjzl9denavz008ed
bc1qwdfjgj3r28dezc9883n2c8ywknnrxa7pz3yw6s

...however, when I try the following (which I've cobbled together by trial and error), I get different addresses (and I've tried various permutations of it, including using CreateBip49):

eMnemonic1.GetPublicKeys(
    BIP0032Path.CreateBip44(
        BIP0032Path.CoinType.Bitcoin,
        0,
        false
    ),
    3
).Select(c => Address.GetP2wpkh(c))

That specific code gives me the following three strings (and of course other permutations result in a different set of three strings), which do all look like valid addresses, but they just don't match what Electrum itself shows...

bc1qp6l5sl7p6y5t6p3xysrycljthducqhahvmpuyp
bc1qu4tpgyu5s7hktwrrg356tvhwefwzjmwh3tf7zv
bc1qqvcxy2md99q94pp4hzeenxthd365a5tjkt0k02

For what it's worth, Electrum's UI (under the Wallet > Information menu) says it's using BIP32, a script type of p2wpkh, and a derivation path of m/0h (though I've never seen that derivation path anywhere else, so I'm not even sure if the "h" is short-hand for something, or if the path is literally just m/0h...) Oh, and this is the portable version of Electrum, v4.5.8

Additionally, I'd like to be able to generate the older "legacy" Electrum addresses as well, but I'm still learning about all this, and I'm still not even sure what the difference is between the older and newer versions, etc...

Any help would be much appreciated.

Tagging @Coding-Enthusiast just in case you don't get a notification of this question otherwise...

p.s. And I'm using the version of this library from NuGet, which looks like it's a year old...? Not sure if that makes a difference, but it's version 0.26.0

[Coding-Enthusiast]

Electrum doesn't use BIP44 path (ie. m/44'/0'/0) to derive its child keys; instead it uses its own derivation path that depends on the mnemonic type which for a SegWit type is m/0'/0.

(though I've never seen that derivation path anywhere else, so I'm not even sure if the "h" is short-hand for something, or if the path is literally just m/0h...)

h is another way of representing hardened indexes in the derivation path. It is the same as '. You can pass the derivation path as a string to BIP0032Path constructor with either h, H or ' and it will parse it. Examples can be found among tests.

Denovo/Src/Tests/Bitcoin/ImprovementProposals/BIP0032PathTests.cs

Lines 32 to 50 in 419207e

	[Theory]
	[InlineData("m", new uint[0])]
	[InlineData("m/", new uint[0])]
	[InlineData("m/0", new uint[1] { 0 })]
	[InlineData("m/5", new uint[1] { 5 })]
	[InlineData("m/0'", new uint[1] { Hard })]
	[InlineData("m/5'", new uint[1] { Hard + 5 })]
	[InlineData("m/0'/1/2'/43", new uint[4] { Hard, 1, Hard + 2, 43 })]
	// With extra spaces:
	[InlineData("m/8 '/ 1/0 ' /12 ", new uint[4] { Hard + 8, 1, Hard, 12 })]
	// Using 'h' and "H" to indicate hardened paths:
	[InlineData("m/3h/2H/6", new uint[3] { Hard + 3, Hard + 2, 6 })]
	// Empty item at the end (extra /) is ignored
	[InlineData("m/5/", new uint[1] { 5 })]
	public void Constructor_FromStringTest(string toUse, uint[] expected)
	{
	var path = new BIP0032Path(toUse);
	Assert.Equal(expected, path.Indexes);
	}

Additionally, I'd like to be able to generate the older "legacy" Electrum addresses as well, but I'm still learning about all this, and I'm still not even sure what the difference is between the older and newer versions, etc...

1. There is an "old" Electrum mnemonic algorithm that is obsolete now (Bitcoin.Net doesn't create them but can verify them). It uses an entirely different algorithm and word-list compared to the current algorithm.
2. There is "legacy" Electrum mnemonic version that is using the current algorithm but would generate P2PKH addresses. AFAIK current Electrum versions allow you to import such mnemonics but won't let you create one anymore through the UI. You should be able to generate one using Bitcoin.Net if you pass the ElectrumMnemonic.MnemonicType.Standard enum to the constructor with an entropy.

[underctrl]

This is exactly what I needed, thanks!

I knew BIP44/49 almost certainly wasn't right, but they were the only options on the BIP0032Path namespace... I just didn't even realize that BIP0032Path was also an object I could construct with any derivation path I wanted...

Also, the explanations of the old/legacy Electrum versions help a lot... I now know how to detect when a mnemonic is one vs the other...

And I now know what the h & ' chars in derivation paths represent :P

Thanks again!