@atala/prism-wallet-sdk / Exports / Apollo
Class: Apollo
Apollo defines the set of cryptographic operations.
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",
}
Apollo
Implements
Table of contents
Constructors
Properties
Methods
- createPrivateKey
- createPublicKey
- createRandomMnemonics
- createRandomSeed
- createSeed
- restorePrivateKey
- restorePublicKey
Constructors
constructor
• new Apollo(): Apollo
Returns
Properties
Ed25519PrivateKey
▪ Static Ed25519PrivateKey: typeof Ed25519PrivateKey = Ed25519PrivateKey
Defined in
Secp256k1PrivateKey
▪ Static Secp256k1PrivateKey: typeof Secp256k1PrivateKey = Secp256k1PrivateKey
Defined in
X25519PrivateKey
▪ Static X25519PrivateKey: typeof X25519PrivateKey = X25519PrivateKey
Defined in
Methods
createPrivateKey
▸ createPrivateKey(parameters): PrivateKey
Creates a private key based on the current cryptographic abstraction
Parameters
| Name | Type |
|---|---|
parameters | Object |
Returns
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,
});
Implementation of
Defined in
createPublicKey
▸ createPublicKey(parameters): PublicKey
Creates a public key based on the current cryptographic abstraction
Parameters
| Name | Type |
|---|---|
parameters | Object |
Returns
Example
Create an EC Key with secp256k1 curve
const privateKey = apollo.createPublicKey({
type: KeyTypes.EC,
curve: Curve.SECP256K1,
raw: Buffer.from(new Arra(64).fill(1)),
});
Implementation of
Defined in
createRandomMnemonics
▸ createRandomMnemonics(): MnemonicWordList
Creates a random set of mnemonic phrases that can be used as a seed for generating a private key.
Returns
Example
This function creates a random mnemonic phrase whose usage is as a seed for generating a private key.
const mnemonics = apollo.createRandomMnemonics();
Implementation of
Defined in
createRandomSeed
▸ createRandomSeed(passphrase?): SeedWords
Creates a random seed and a corresponding set of mnemonic phrases.
Parameters
| Name | Type |
|---|---|
passphrase? | string |
Returns
Example
This function creates a random mnemonic phrase and seed.
const {mnemonics, seed} = apollo.createRandomSeed();
Implementation of
Defined in
createSeed
▸ createSeed(mnemonics, passphrase?): Seed
Takes in a set of mnemonics and a passphrase, and returns a seed object used to generate a private key.
Parameters
| Name | Type |
|---|---|
mnemonics | MnemonicWordList |
passphrase? | string |
Returns
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");
Implementation of
Defined in
restorePrivateKey
▸ restorePrivateKey(key): PrivateKey
Restores a PrivateKey from the given StorableKey
Parameters
| Name | Type |
|---|---|
key | StorableKey |
Returns
PrivateKey instance
Throws
if the restoration process fails
Implementation of
KeyRestoration.restorePrivateKey
Defined in
restorePublicKey
▸ restorePublicKey(key): PublicKey
Restores a PublicKey from the given StorableKey
Parameters
| Name | Type |
|---|---|
key | StorableKey |
Returns
PublicKey instance
Throws
if the restoration process fails, this method throws an error
Implementation of
KeyRestoration.restorePublicKey