Keys

To perform actions using an account and private-public key pairs with xpla.js, you need an implementation of the Key class, which provides an abstraction around the signing functions of an account. There are multiple implementations available:

RawKey MnemonicKey CLIKey

You can also create a custom signing solution by extending the base Key class.

RawKey #

The most basic implementation of a Key is a RawKey, which is created using a plain private key. RawKey wraps the 32 bytes of a private key and supplies a corresponding public key:

import { RawKey } from '@xpla/xpla.js';
import {randomBytes} from 'crypto'
let see = console.log;

const raw_key = new RawKey(randomBytes(32));

see(raw_key.publicKey)//SimplePublicKey { key: 'AlNdglClnFJMwdeFGlfFTAwbx7rxKxWbgN/lwj5mQ3vw' }
see(raw_key.privateKey)//<Buffer 53 e2 53 0b 29 c4 9d 54 b3 66 a4 61 7b d3 e2 6e 4c e5 41 cd 12 a6 e9 27 8a 97 61 1c 55 6e cd 4c>
see(raw_key.accAddress)//xpla1ptj88nsljjr9agx07hahu6etv43acksy2q44sd

MnemonicKey #

A MnemonicKey derives itself from a 24-word BIP-39 mnemonic as opposed to the bytes of a private key. A MnemonicKey has various levels of definition:

• Supply no arguments for the mnemonic to be randomly generated ( effectively generating a random key ).
• Supply only a 24-word BIP-39 mnemonic to generate a corresponding key.
• Supply a full HD path (using either a random or particular mnenomic).

import { MnemonicKey } from '@xpla/xpla.js';
const see = console.log;

const MNE_KEY_RANDOM = new MnemonicKey();

see(MNE_KEY_RANDOM.mnemonic)  // famous { ... } myth world size
see(MNE_KEY_RANDOM.privateKey) // <Buffer 4f e5 { ... } 51 a4 41 9c>
see(MNE_KEY_RANDOM.publicKey) // SimplePublicKey { key: 'A8TNSJhn6gGHgY2ohJnkOaZz7Y0FaW/QeytGBaqCLIJU' }
see(MNE_KEY_RANDOM.accAddress) // xpla1l63e8q7yjyd77qanwfgvl43ulagf34a2xzcuv4


const MNE_KEY_EXACT  = new MnemonicKey({
  mnemonic: "squirrel future level fan world organ daring thing color orange sausage cross fault interest blast wink audit unfair satoshi solution track indoor sun edit",
});

const MNE_KEY_RANDOM_WITH_HD_PATH = new MnemonicKey({
  // mnemonic: "",   // optional, will be random if not provided
  coinType: 60,               // optional, default
  account : 0,                 // optional, default
  index   : 0,                 // optional, default
});

const MNE_KEY_FULLY_RESOLVED = new MnemonicKey({
  mnemonic: "squirrel future level fan world organ daring thing color orange sausage cross fault interest blast wink audit unfair satoshi solution track indoor sun edit",
  coinType: 60,
  account : 0,
  index   : 0,
});

Specifying an HD path #

MnemonicKey can used to recover a wallet with a particular BIP44 HD path: m/44'/${coinType}'/${account}'/0/${index}.

For example, to recover a mnemonic with the old XPLA Vault HD path using coin type for ATOM (118):

const mne_key = new MnemonicKey({
  mnemonic: "[ Your BIP39 mnemonic ]",
  coinType: 118     // <--------- Cosmos' coin type ( XPLA Chain had inherited initially )
});

• BIP-39 Mnemonics

• Coin Types Numbers 60 and 118 above refer to “coin-types” for Cosmos and Ethereum blockchains accordingly. These numbers are defined according to the BIP044 standard. You can find more information here .

Custom Key Implementation #

If you need to write your own key management solution, you will need to subclass the abstract Key class and provide your own signing function. Instead of exposing details pertaining to your private key, you can specify a sign() function that forwards the signing request to a server or to a hardware wallet. The remaining functions related to signing (createSignature() and signTx()) are automatically provided and use sign() underneath.

The following code listing is close to the implementation of RawKey, which illustrates how to write a custom Key:

import SHA256 from 'crypto-js/sha256';
import * as secp256k1 from 'secp256k1';
import { Key } from '@xpla/xpla.js';

// An implementation of the Key interfaces that uses a raw private key.
export class NaiveCustomImplementation extends Key {

  // Raw private key, in bytes.
  public privateKey: Buffer;

  constructor(privateKey: Buffer) {
    const publicKey = secp256k1.publicKeyCreate(
      new Uint8Array(privateKey),
      true
    );
    super(new SimplePublicKey(Buffer.from(publicKey).toString('base64')));
    this.privateKey = privateKey;
  }

  public sign(payload: Buffer): Promise<Buffer> {
    const hash = Buffer.from(SHA256(payload.toString()).toString(), 'hex');
    const { signature } = secp256k1.ecdsaSign(
      Uint8Array.from(hash),
      Uint8Array.from(this.privateKey)
    );
    return new Promise(()=>{Buffer.from(signature)});
  }
}

Note that you must call super() with the public key to generate the relevant account and validator public keys associated with your key.