@twin.org/crypto 0.0.1-next.1

package/dist/types/keys/slip0010.d.ts

@@ -0,0 +1,38 @@
+import type { Bip32Path } from "./bip32Path";
+import { KeyType } from "../models/keyType";
+/**
+ * Class to help with slip0010 key derivation
+ * https://github.com/satoshilabs/slips/blob/master/slip-0010.md.
+ */
+export declare class Slip0010 {
+    /**
+     * Get the master key from the seed.
+     * @param seed The seed to generate the master key from.
+     * @param keyType The key type.
+     * @returns The key and chain code.
+     * @throws If the seed is invalid.
+     */
+    static getMasterKeyFromSeed(seed: Uint8Array, keyType?: KeyType): {
+        privateKey: Uint8Array;
+        chainCode: Uint8Array;
+    };
+    /**
+     * Derive a key from the path.
+     * @param seed The seed.
+     * @param path The path.
+     * @param keyType The key type.
+     * @returns The key and chain code.
+     */
+    static derivePath(seed: Uint8Array, path: Bip32Path, keyType?: KeyType): {
+        privateKey: Uint8Array;
+        chainCode: Uint8Array;
+    };
+    /**
+     * Get the public key from the private key.
+     * @param privateKey The private key.
+     * @param keyType The key type.
+     * @param withZeroByte Include a zero bute prefix.
+     * @returns The public key.
+     */
+    static getPublicKey(privateKey: Uint8Array, keyType?: KeyType, withZeroByte?: boolean): Uint8Array;
+}

package/dist/types/models/keyType.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The names of the key types.
+ */
+export declare const KeyType: {
+    /**
+     * Ed25519.
+     */
+    readonly Ed25519: 0;
+    /**
+     * Secp256k1.
+     */
+    readonly Secp256k1: 1;
+};
+/**
+ * Key types.
+ */
+export type KeyType = (typeof KeyType)[keyof typeof KeyType];

package/dist/types/otp/hotp.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Perform HOTP.
+ * Implementation of https://datatracker.ietf.org/doc/html/rfc4226 .
+ */
+export declare class Hotp {
+    /**
+     * Generate a counter based One Time Password.
+     * @param key Key for the one time password.
+     * @param counter This should be stored by the application,
+     * must be user specific, and be incremented for each request.
+     * @returns The one time password.
+     */
+    static generate(key: Uint8Array, counter: number): string;
+}

package/dist/types/otp/totp.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Perform TOTP.
+ * Implementation of https://datatracker.ietf.org/doc/html/rfc4226 .
+ */
+export declare class Totp {
+    /**
+     * Generate a time based One Time Password.
+     * @param key Key for the one time password.
+     * @param interval The time step of the counter.
+     * @param timestamp The timestamp.
+     * @returns The one time password.
+     */
+    static generate(key: Uint8Array, interval?: number, timestamp?: number): string;
+    /**
+     * Check a One Time Password based on a timer.
+     * @param token Passcode to validate.
+     * @param key Key for the one time password. This should be unique and secret for
+     * every user as it is the seed used to calculate the HMAC.
+     * @param window The allowable margin for the counter.
+     * @param interval The time step of the counter.
+     * @param timestamp The timestamp now.
+     * @returns Undefined if failure, delta on success
+     */
+    static verify(token: string, key: Uint8Array, window?: number, interval?: number, timestamp?: number): number | undefined;
+    /**
+     * Generate a secret.
+     * @param length The length of the secret to generate.
+     * @returns The secret encoded as base32.
+     */
+    static generateSecret(length: number): string;
+    /**
+     * Convert the secret back to bytes.
+     * @param secretBase32 The secret encoded as base32.
+     * @returns The bytes of the secret.
+     */
+    static secretToBytes(secretBase32: string): Uint8Array;
+    /**
+     * Generate a url for use with authenticator apps.
+     * See https://github.com/google/google-authenticator/wiki/Key-Uri-Format .
+     * @param issuer The issuer of the totp.
+     * @param label The label that will show in auth apps.
+     * @param secretBase32 The secret as base 32.
+     * @returns The url.
+     */
+    static generateAuthUrl(issuer: string, label: string, secretBase32: string): string;
+}

package/dist/types/passwords/passwordGenerator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generate random passwords.
+ */
+export declare class PasswordGenerator {
+    /**
+     * Generate a password of given length.
+     * @param length The length of the password to generate.
+     * @returns The random password.
+     */
+    static generate(length: number): string;
+}

package/dist/types/passwords/passwordValidator.d.ts

@@ -0,0 +1,22 @@
+import { type IValidationFailure } from "@twin.org/core";
+/**
+ * Test password strength.
+ * Ref https://www.owasp.org/index.php/Authentication_Cheat_Sheet#Implement_Proper_Password_Strength_Controls .
+ */
+export declare class PasswordValidator {
+    /**
+     * Test the strength of the password.
+     * @param property The name of the property.
+     * @param password The password to test.
+     * @param failures The list of failures to add to.
+     * @param options Options to configure the testing.
+     * @param options.minLength The minimum length of the password, defaults to 8.
+     * @param options.maxLength The minimum length of the password, defaults to 128.
+     * @param options.minPhraseLength The minimum length of the password for it to be considered a pass phrase.
+     */
+    static validate(property: string, password: string, failures: IValidationFailure[], options?: {
+        minLength?: number;
+        maxLength?: number;
+        minPhraseLength?: number;
+    }): void;
+}

package/docs/changelog.md

@@ -0,0 +1,5 @@
+# @twin.org/crypto - Changelog
+
+ ## v0.0.1
+
+- Added: Bip44

package/docs/examples.md

@@ -0,0 +1 @@
+# @twin.org/crypto - Examples

package/docs/reference/classes/Bech32.md

@@ -0,0 +1,89 @@
+# Class: Bech32
+
+Bech32 encoding and decoding.
+
+## Constructors
+
+### new Bech32()
+
+> **new Bech32**(): [`Bech32`](Bech32.md)
+
+#### Returns
+
+[`Bech32`](Bech32.md)
+
+## Methods
+
+### encode()
+
+> `static` **encode**(`humanReadablePart`, `data`): `string`
+
+Encode the buffer.
+
+#### Parameters
+
+• **humanReadablePart**: `string`
+
+The header.
+
+• **data**: `Uint8Array`
+
+The data to encode.
+
+#### Returns
+
+`string`
+
+The encoded data.
+
+***
+
+### decode()
+
+> `static` **decode**(`bech`): `object`
+
+Decode a bech32 string.
+
+#### Parameters
+
+• **bech**: `string`
+
+The text to decode.
+
+#### Returns
+
+`object`
+
+The decoded data or undefined if it could not be decoded.
+
+##### humanReadablePart
+
+> **humanReadablePart**: `string`
+
+##### data
+
+> **data**: `Uint8Array`
+
+#### Throws
+
+An error if the decoding fails.
+
+***
+
+### isBech32()
+
+> `static` **isBech32**(`bech`): `bech is string`
+
+Is the input a bech 32 address.
+
+#### Parameters
+
+• **bech**: `unknown`
+
+The value to test.
+
+#### Returns
+
+`bech is string`
+
+True if this is potentially a match.

package/docs/reference/classes/Bip32Path.md

@@ -0,0 +1,117 @@
+# Class: Bip32Path
+
+Class to help with bip32 paths.
+
+## Constructors
+
+### new Bip32Path()
+
+> **new Bip32Path**(`initialPath`?): [`Bip32Path`](Bip32Path.md)
+
+Create a new instance of Bip32Path.
+
+#### Parameters
+
+• **initialPath?**: `string`
+
+Initial path to create.
+
+#### Returns
+
+[`Bip32Path`](Bip32Path.md)
+
+## Methods
+
+### fromPath()
+
+> `static` **fromPath**(`bip32Path`): [`Bip32Path`](Bip32Path.md)
+
+Construct a new path by cloning an existing one.
+
+#### Parameters
+
+• **bip32Path**: [`Bip32Path`](Bip32Path.md)
+
+The path to clone.
+
+#### Returns
+
+[`Bip32Path`](Bip32Path.md)
+
+A new instance of Bip32Path.
+
+***
+
+### toString()
+
+> **toString**(): `string`
+
+Converts the path to a string.
+
+#### Returns
+
+`string`
+
+The path as a string.
+
+***
+
+### push()
+
+> **push**(`index`): `void`
+
+Push a new index on to the path.
+
+#### Parameters
+
+• **index**: `number`
+
+The index to add to the path.
+
+#### Returns
+
+`void`
+
+***
+
+### pushHardened()
+
+> **pushHardened**(`index`): `void`
+
+Push a new hardened index on to the path.
+
+#### Parameters
+
+• **index**: `number`
+
+The index to add to the path.
+
+#### Returns
+
+`void`
+
+***
+
+### pop()
+
+> **pop**(): `void`
+
+Pop an index from the path.
+
+#### Returns
+
+`void`
+
+***
+
+### numberSegments()
+
+> **numberSegments**(): `number`[]
+
+Get the segments.
+
+#### Returns
+
+`number`[]
+
+The segments as numbers.

package/docs/reference/classes/Bip39.md

@@ -0,0 +1,121 @@
+# Class: Bip39
+
+Implementation of Bip39 for mnemonic generation.
+
+## Constructors
+
+### new Bip39()
+
+> **new Bip39**(): [`Bip39`](Bip39.md)
+
+#### Returns
+
+[`Bip39`](Bip39.md)
+
+## Methods
+
+### randomMnemonic()
+
+> `static` **randomMnemonic**(`strength`, `words`): `string`
+
+Generate a random mnemonic.
+
+#### Parameters
+
+• **strength**: `number` = `256`
+
+The strength of the mnemonic to generate, defaults to 256.
+
+• **words**: `string`[] = `wordlist`
+
+The wordlist to use, defaults to the English wordlist.
+
+#### Returns
+
+`string`
+
+The random mnemonic.
+
+#### Throws
+
+Error if the length is not a multiple of 32.
+
+***
+
+### entropyToMnemonic()
+
+> `static` **entropyToMnemonic**(`entropy`, `words`): `string`
+
+Generate a mnemonic from the entropy.
+
+#### Parameters
+
+• **entropy**: `Uint8Array`
+
+The entropy to generate.
+
+• **words**: `string`[] = `wordlist`
+
+The wordlist to use, defaults to the English wordlist.
+
+#### Returns
+
+`string`
+
+The mnemonic.
+
+#### Throws
+
+Error if the length of the entropy is not a multiple of 4, or is less than 16 or greater than 32.
+
+***
+
+### mnemonicToSeed()
+
+> `static` **mnemonicToSeed**(`mnemonic`, `password`?): `Uint8Array`
+
+Convert a mnemonic to a seed.
+
+#### Parameters
+
+• **mnemonic**: `string`
+
+The mnemonic to convert.
+
+• **password?**: `string`
+
+The password to apply to the seed generation.
+
+#### Returns
+
+`Uint8Array`
+
+The seed.
+
+***
+
+### mnemonicToEntropy()
+
+> `static` **mnemonicToEntropy**(`mnemonic`, `words`): `Uint8Array`
+
+Convert the mnemonic back to entropy.
+
+#### Parameters
+
+• **mnemonic**: `string`
+
+The mnemonic to convert.
+
+• **words**: `string`[] = `wordlist`
+
+The wordlist to use, defaults to the English wordlist.
+
+#### Returns
+
+`Uint8Array`
+
+The entropy.
+
+#### Throws
+
+Error if the number of words is not a multiple of 3.

package/docs/reference/classes/Bip44.md

@@ -0,0 +1,173 @@
+# Class: Bip44
+
+Implementation of Bip44 for address generation.
+
+## Constructors
+
+### new Bip44()
+
+> **new Bip44**(): [`Bip44`](Bip44.md)
+
+#### Returns
+
+[`Bip44`](Bip44.md)
+
+## Methods
+
+### keyPair()
+
+> `static` **keyPair**(`seed`, `keyType`, `coinType`, `accountIndex`, `isInternal`, `addressIndex`): `object`
+
+Generate a bip44 key pair from the seed and parts.
+
+#### Parameters
+
+• **seed**: `Uint8Array`
+
+The account seed.
+
+• **keyType**: [`KeyType`](../type-aliases/KeyType.md)
+
+The key type.
+
+• **coinType**: `number`
+
+The coin type.
+
+• **accountIndex**: `number`
+
+The account index.
+
+• **isInternal**: `boolean`
+
+Is this an internal address.
+
+• **addressIndex**: `number`
+
+The address index.
+
+#### Returns
+
+`object`
+
+The key pair.
+
+##### privateKey
+
+> **privateKey**: `Uint8Array`
+
+##### publicKey
+
+> **publicKey**: `Uint8Array`
+
+#### Throws
+
+Error if the address type is not supported.
+
+***
+
+### path()
+
+> `static` **path**(`coinType`, `accountIndex`, `isInternal`, `addressIndex`): [`Bip32Path`](Bip32Path.md)
+
+Generate a bip44 path based on all its parts.
+
+#### Parameters
+
+• **coinType**: `number`
+
+The coin type.
+
+• **accountIndex**: `number`
+
+The account index.
+
+• **isInternal**: `boolean`
+
+Is this an internal address.
+
+• **addressIndex**: `number`
+
+The address index.
+
+#### Returns
+
+[`Bip32Path`](Bip32Path.md)
+
+The generated path.
+
+***
+
+### basePath()
+
+> `static` **basePath**(`coinType`): `string`
+
+Create a bip44 base path for the provided coin type.
+
+#### Parameters
+
+• **coinType**: `number`
+
+The coin type.
+
+#### Returns
+
+`string`
+
+The bip44 address base path.
+
+***
+
+### addressBech32()
+
+> `static` **addressBech32**(`seed`, `keyType`, `hrp`, `coinType`, `accountIndex`, `isInternal`, `addressIndex`): `object`
+
+Generate a bech32 address from the seed and parts.
+
+#### Parameters
+
+• **seed**: `Uint8Array`
+
+The account seed.
+
+• **keyType**: [`KeyType`](../type-aliases/KeyType.md)
+
+The key type.
+
+• **hrp**: `string`
+
+The human readable part of the address.
+
+• **coinType**: `number`
+
+The coin type.
+
+• **accountIndex**: `number`
+
+The account index.
+
+• **isInternal**: `boolean`
+
+Is this an internal address.
+
+• **addressIndex**: `number`
+
+The address index.
+
+#### Returns
+
+`object`
+
+The generated path and the associated keypair.
+
+##### address
+
+> **address**: `string`
+
+##### privateKey
+
+> **privateKey**: `Uint8Array`
+
+##### publicKey
+
+> **publicKey**: `Uint8Array`