How to generate key pairs from mnemonic?

[gluneau]

Hello, I'm trying to find any documentation that would show me how to generate a privateKey and a publicKey.

This does not work yet, what am I missing?

const mnemonic = 'unit jelly zone token virus blue parrot pottery stage girl version grief left black foam donkey fatigue silly bitter fox manage note indoor leisure'
const ada = require('js-chain-libs/js_chain_libs')
const account = ada.setAccountFromMnemonic(mnemonic)
const privateKey = account.privateKey
const publicKey = account.publicKey

Are there a developer's discussion group somewhere?

[jpcapurro-atixlabs]

Generating a key pair from a mnemonic is not supported in the js-chain-libs, and it isn't likely that it'll be added.

The wallet example uses a javascript bip39 library to get a seed from the mnemonic, and then uses the chain libs (see getAccountFromSeed function) to create a private key from the seed.

Then the public key, address and everything else can be derived from the private key.

This is the preferred way to do what you're trying to do.

However, please take into consideration that the wallet uses the seed directly, and a standards-compliant implementation should use bip32 instead.

[gluneau]

Here is my newest test:

const bip39 = require('bip39')
const ada = require('js-chain-libs/js_chain_libs')

const mnemonic = 'unit jelly zone token virus blue parrot pottery stage girl version grief left black foam donkey fatigue silly bitter fox manage note indoor leisure'
const seed = bip39.mnemonicToSeedSync(mnemonic)
const account = ada.getAccountFromSeed(seed) // Does not work, function does not exists
const privateKey = account.privateKey
const publicKey = account.publicKey

Then I looked into your wasm wrapper and tried this:

const privateKey = ada.PrivateKey.from_normal_bytes(seed.slice(0, 32))

but that return a pointer!

Are we missing basic key management functions in the library?
Can you help with finding the simplest way to make a private/public key?

Thanks.

[jpcapurro-atixlabs]

ada.PrivateKey.from_normal_bytes(seed.slice(0, 32)) returns a PrivateKey object (yes, internally it's a pointer, but it shouldn't matter to you or me as consumers of the library).

The js-chain-libs is a js wrapper around a wasm implementation of jormungandr's cryptography, and it exposes a series of objects which can be instantiated and represent the different domain entities, such as a private key (yes, it's pretty OOP-ey).

If you want to derivate the public key from the private key, you should call the corresponding method on the PrivateKey object. For example:

const privateKey = ada.PrivateKey.from_normal_bytes(seed.slice(0, 32))
const publicKey: PublicKey = privateKey.to_public();
// if you want the private key as a string (not bip39)

const secret = privateKey.to_bech32();

Documentation for all this methods AFAIK does not exist in a user-friendly format (😭). What I do instead is look at the generated js files. For example, in the wallet I'd look at <wallet_dir>/node_modules/js-chain-libs/js_chain_libs.js and see the API for the PrivateKey object as:

/**
* ED25519 signing key, either normal or extended
*/
export class PrivateKey {

    static __wrap(ptr) {
        const obj = Object.create(PrivateKey.prototype);
        obj.ptr = ptr;

        return obj;
    }

    free() {
        const ptr = this.ptr;
        this.ptr = 0;

        wasm.__wbg_privatekey_free(ptr);
    }
    /**
    * Get private key from its bech32 representation
    * ```javascript
    * PrivateKey.from_bech32('ed25519_sk1ahfetf02qwwg4dkq7mgp4a25lx5vh9920cr5wnxmpzz9906qvm8qwvlts0');
    * ```
    * For an extended 25519 key
    * ```javascript
    * PrivateKey.from_bech32('ed25519e_sk1gqwl4szuwwh6d0yk3nsqcc6xxc3fpvjlevgwvt60df59v8zd8f8prazt8ln3lmz096ux3xvhhvm3ca9wj2yctdh3pnw0szrma07rt5gl748fp');
    * ```
    * @param {string} bech32_str
    * @returns {PrivateKey}
    */
    static from_bech32(bech32_str) {
        const ret = wasm.privatekey_from_bech32(passStringToWasm(bech32_str), WASM_VECTOR_LEN);
        return PrivateKey.__wrap(ret);
    }
    /**
    * @returns {PublicKey}
    */
    to_public() {
        const ret = wasm.privatekey_to_public(this.ptr);
        return PublicKey.__wrap(ret);
    }
    /**
    * @returns {PrivateKey}
    */
    static generate_ed25519() {
        const ret = wasm.privatekey_generate_ed25519();
        return PrivateKey.__wrap(ret);
    }

A healthier alternative is to look at what ctags can generate from the file (I use vim-tagbar for this):

The file has jsdoc strings so a nice html documentation could probably be generated, but no one looked into it yet 🙃.

Keep in mind, however, that instantiating the js-chain-libs is not as simple as just require-ing the package, so your snippet wouldn't work even if the getAccountFromSeed function existed in the PrivateKey object, because the package must be import()ed and the resulting promise must be awaited.

This last paragraph only applies to the way the js-chain-libs are packaged in the npm release, there are other ways of packaging them which you can look at in the wasm-pack documentation, which might be more appropiate or easier to integrate into what you're trying to build.

[gluneau]

I think I'm getting somewhere:

const bip39 = require('bip39')
const ada = require('js-chain-libs/js_chain_libs')

async ada () {
  const mnemonic = 'unit jelly zone token virus blue parrot pottery stage girl version grief left black foam donkey fatigue silly bitter fox manage note indoor leisure'
  const seed = bip39.mnemonicToSeedSync(mnemonic)
  const extPrivateKey = await ada.PrivateKey.from_normal_bytes(seed.slice(0, 32))
  const privateKey = extPrivateKey.to_bech32()
  const account = ada.Account.single_from_public_key(extPrivateKey.to_public())
  const address = account.to_address('AddressDiscrimination.Production').to_string('addr')
  return { address, privateKey }
}

The results:

privateKey: ed25519_sk1q05jj6mxssx2379hjszr7jhlmhqw778xad9tvdasy77jsdwyuyzqea2hmf
address: addr1q4xx8sdp7yvwxvp4m3vqzes3rn2vynscyj9lvv7y2mjq86caw9z8jznrp8j

Looking ok, but I'm not sure about networkDiscrimination or the addressPrefix, ideas?
Also, any wallets you would suggest for me to test my mnemonic seed to confirm I'm getting the right keys?

[gluneau]

@jpcapurro-atixlabs can you still help?

[jpcapurro-atixlabs]

Hi, sorry for the late reply.

I'm not sure about networkDiscrimination or the addressPrefix, ideas?

networkDiscrimination should be one of the values exported by the js-chain-libs as AddressDiscrimination:

(from the js-chain-libs)

/**
* Allow to differentiate between address in
* production and testing setting, so that
* one type of address is not used in another setting.
* Example
* ```javascript
* let discriminant = AddressDiscrimination.Test;
* let address = Address::single_from_public_key(public_key, discriminant);
* ```
*/
export const AddressDiscrimination = Object.freeze({ Production:0,Test:1, });

As for the addressPrefix, it is just a string that's preppended to the address and AFAIK it doesn't really matter.
Daedalus uses addr and jcli uses ca.

Also, any wallets you would suggest for me to test my mnemonic seed to confirm I'm getting the right keys?

As mentioned in a previous issue, the example wallet is not a standard-compliant implementation. I would reccomend you to test your implementation against Daedalus, Yoroi or even AdaLite.

Let me know you need any further help with this issue.

[SebastienGllmt]

You can use the EMURGO fork of js-chain-libs which contains all the functionality you need for a wallet (https://github.com/Emurgo/js-chain-libs/blob/emurgo/src/lib.rs#L92). You can see the Yoroi extension for how we use this https://github.com/Emurgo/yoroi-frontend