Class Apollo

Apollo defines the set of cryptographic operations that are used in the Atala PRISM.

Abstraction

We by default are implementing Secp256k1, Ed25519 and X25519 Private and Public key from our generic abstractions. When you are using one of those type of keys, for example with:

 const privateKey = apollo.createPrivateKey({
   type: KeyTypes.EC,
   curve: Curve.ED25519,
 });

All the properties you pass to the createPrivateKey are just the default keyProperty keys and the values are strings, buffers are represented in hex format also as strings to simplify conversion later

You can know check if this key can sign with:

if (privateKey.isSignable()) {
 //the sign method will be available inside this if
 privateKey.sign(message)
}
//not outside

const signature = privateKey.isSignable() && privateKey.sign(message)
//This last one would also would but if your key was not signable would return false

PublicKeys follow the same concept, imagine you already have an instance of a publicKey, then..

if (publicKey.canVerify()) {
 privateKey.verify(challenge, signature)
}
//not outside

All keys know also have a generic list of properties which can be accessed at any stage, for example:

privateKey.getProperty(KeyProperties.curve)

Would give your the Curve value.

Find below all the complete list of KeyProperties that are available.

export enum KeyProperties {
  /// The 'kid'  represents a key's identifier.
  kid = "kid",
  /// The 'algorithm'  corresponds to the cryptographic algorithm associated with the key.,
  algorithm = "algorithm",
  /// The 'curve'  represents the elliptic curve used for an elliptic-curve key.,
  curve = "curve",
  /// The 'seed'  corresponds to the seed value from which a key is derived.,
  seed = "seed",
  /// The 'rawKey'  refers to the raw binary form of the key.,
  rawKey = "raw",
  /// The 'derivationPath'  refers to the path used to derive a key in a hierarchical deterministic (HD) key generation scheme.,
  derivationPath = "derivationPath",
  index = "index",
  /// The 'type'  denotes the type of the key.,
  type = "type",
  /// The 'curvePointX'  represents the x-coordinate of a curve point for an elliptic-curve key.,
  curvePointX = "curvePoint.x",
  /// The 'curvePointY'  represents the y-coordinate of a curve point for an elliptic-curve key.,
  curvePointY = "curvePoint.y",
}

Hierarchy

  • Apollo

Implements

Constructors

constructor

Properties

Ed25519PrivateKey Secp256k1PrivateKey X25519PrivateKey

Methods

createPrivateKey createRandomMnemonics createRandomSeed createSeed

Constructors

constructor

Properties

Static Ed25519PrivateKey

Ed25519PrivateKey: typeof Ed25519PrivateKey = Ed25519PrivateKey

Static Secp256k1PrivateKey

Secp256k1PrivateKey: typeof Secp256k1PrivateKey = Secp256k1PrivateKey

Static X25519PrivateKey

X25519PrivateKey: typeof X25519PrivateKey = X25519PrivateKey

Methods

createPrivateKey

  • Creates a private key based on the current cryptographic abstraction

    Parameters

    Returns PrivateKey

    Example

    Create an EC Key with secp256k1 curve

     const privateKey = apollo.createPrivateKey({
       type: KeyTypes.EC,
       curve: Curve.SECP256K1,
       seed: Buffer.from(seed.value).toString("hex"),
     });

    Example

    Create an EC Key with secp256k1 curve, but also specify a derivationPath

     const privateKey = apollo.createPrivateKey({
       type: KeyTypes.EC,
       curve: Curve.SECP256K1,
       seed: Buffer.from(seed.value).toString("hex"),
       derivationPath: "m/0'/0'/0'"
     });

    Example

    Create an EC Key with ed25519 curve, ED25519 keys do not use derivation, passing the seed or derivation path will make no effect. Calling this function just generates a new random privateKey for that curve

     const privateKey = apollo.createPrivateKey({
       type: KeyTypes.EC,
       curve: Curve.ED25519,
     });

    Example

    Create an EC Key with X25519 curve, X25519 keys do not use derivation, passing the seed or derivation path will make no effect. Calling this function just generates a new random privateKey for that curve

     const privateKey = apollo.createPrivateKey({
       type: KeyTypes.Curve25519,
       curve: Curve.X25519,
     });

createRandomMnemonics

createRandomSeed

  • Creates a random seed and a corresponding set of mnemonic phrases.

    Parameters

    • Optional passphrase: string

    Returns SeedWords

    Example

    This function creates a random mnemonic phrase and seed.

     const {mnemonics, seed} = apollo.createRandomSeed();

createSeed

  • Takes in a set of mnemonics and a passphrase, and returns a seed object used to generate a private key.

    Parameters

    Returns Seed

    Example

    This function takes mnemonics and passphrases and creates a seed object to generate a private key. It may throw an error if the mnemonics are invalid.

     const seed = apollo.createSeed(mnemonics, "my-secret-passphrase");

Settings

Member Visibility

Theme

On This Page