@metamask-previews/key-tree 0.0.0-stage → 10.1.1-preview-4dd847ca3

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Changed
+
+- **BREAKING:** Drop CommonJS support ([#11361](https://github.com/MetaMask/core/pull/11361))
+  - The package is now ESM-only. The `require` export condition and the `main`, `module`, and `types` fields are removed, and `exports` only has `types` and `default` conditions.
+  - Consumers that load this package with `require()` must switch to `import`, or use a Node.js version that supports `require(esm)`.
+- **BREAKING:** Bump minimum supported Node.js version to `^22.14.0 || ^24 || ^26` ([#11361](https://github.com/MetaMask/core/pull/11361))
+- **BREAKING:** Compile to `ES2022` instead of `ES2020` ([#11360](https://github.com/MetaMask/core/pull/11360))
+  - Consumers that bundle this package for environments that do not support `ES2022` must transpile it.
+- Replace the `@metamask/utils` dependency with `@metamask/byte-utils` and `@metamask/type-utils` ([#11361](https://github.com/MetaMask/core/pull/11361))
+- Bump `@noble/curves` from `^1.8.1` to `^1.9.7`, `@noble/hashes` from `^1.3.2` to `^1.8.0`, and `@scure/base` from `^1.0.0` to `^1.2.6` ([#11361](https://github.com/MetaMask/core/pull/11361))
+- This package was migrated from `MetaMask/key-tree` to the `MetaMask/core` monorepo ([#11354](https://github.com/MetaMask/core/pull/11354))
+  - See [`MetaMask/key-tree`](https://github.com/MetaMask/key-tree/blob/742c995fa27144d038941df5bddbc7351ee0e8ff/CHANGELOG.md) for the original changelog.
+
+[Unreleased]: https://github.com/MetaMask/core/

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 MetaMask
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,164 @@
-# Temporary Holding Version
+# @metamask/key-tree
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An interface over [SLIP-10], [BIP-32], and [BIP-44] key derivation paths.
+
+This library was audited by Cure53 in February 2023, and April 2024. The audit reports can be found [here](./audits).
+
+## Installation
+
+`yarn add @metamask/key-tree`
+
+or
+
+`npm install @metamask/key-tree`
+
+## Usage
+
+This package is designed to accommodate the creation of keys for any level of a [SLIP-10] or [BIP-44] path.
+Recall that a [BIP-44] HD tree path consists of the following nodes (and depths):
+
+> `m / 44' / coin_type' / account' / change / address_index`
+>
+> `0 / 1 / 2 / 3 / 4 / 5`
+
+Where `m` is the "master" or seed node, `coin_type` indicates the protocol for which deeper keys are intended,
+and `address_index` usually furnishes key pairs intended for user addresses / accounts.
+For details, refer to the [BIP-44] specification.
+For the authoritative list of protocol `coin_type` indices, see [SLIP-44].
+
+The [SLIP-10] interface provides a more generic way for deriving keys, which is not constrained to the [BIP-44] path
+nodes. Currently only Secp256k1 and Ed25519 are supported for [SLIP-10], but NIST P-256 may be added if there is
+sufficient demand for it.
+
+This package exports a few classes intended to facilitate the creation of keys in contexts with different privileges.
+They are used as follows.
+
+```typescript
+import { BIP44CoinTypeNode } from '@metamask/key-tree';
+
+// Per SLIP-44, Ethereum has a coin_type of 60.
+// Ethereum is only used by way of example.
+const coinType = 60;
+
+// Imagine that this takes place in some privileged context with access to
+// the user's secret recovery phrase.
+const secretRecoveryPhrase = getSecretRecoveryPhrase();
+
+const coinTypeNode = await BIP44CoinTypeNode.fromDerivationPath([
+  `bip39:${secretRecoveryPhrase}`,
+  `bip32:44'`, // By BIP-44, the "purpose" node must be "44'"
+  `bip32:${coinType}'`,
+]);
+
+// Imagine that this is some Node.js stream, but it could be anything that
+// can transmit JSON messages, such as window.postMessage.
+// Alternatively you can use `coinTypeNode.extendedKey` as well.
+stream.write(coinTypeNode.toJSON());
+
+//===============================
+// Then, on the receiving end...
+//===============================
+
+import { getBIP44AddressKeyDeriver } from '@metamask/key-tree';
+
+// Get the node sent from the privileged context.
+// It will have the following shape:
+//   {
+//     privateKey, // A hexadecimal string of the private key
+//     publicKey, // A hexadecimal string of the public key
+//     chainCode, // A hexadecimal string of the chain code
+//     depth, // The number 2, which is the depth of coin_type nodes
+//     parentFingerprint, // The fingerprint of the parent node as number
+//     index, // The index of the node as number
+//     coin_type, // In this case, the number 60
+//     path, // For visualization only. In this case: m / 44' / 60'
+//   }
+const coinTypeNode = await getCoinTypeNode();
+
+// Get an address key deriver for the coin_type node.
+// In this case, its path will be: m / 44' / 60' / 0' / 0 / address_index
+// Alternatively you can use an extended key (`xprv`) as well.
+const addressKeyDeriver = getBIP44AddressKeyDeriver(coinTypeNode);
+
+// These are Uint8Array representations of the extended private keys for
+// the respective addresses.
+
+// m / 44' / 60' / 0' / 0 / 0
+const addressKey0 = await addressKeyDeriver(0);
+
+// m / 44' / 60' / 0' / 0 / 1
+const addressKey1 = await addressKeyDeriver(1);
+
+// m / 44' / 60' / 0' / 0 / 2'
+const addressKey2 = await addressKeyDeriver(2, true);
+
+// Now, the extended private keys can be used to derive the corresponding public
+// keys and protocol addresses.
+```
+
+You can derive SLIP-10 keys as follows.
+
+```typescript
+import { SLIP10Node } from '@metamask/key-tree';
+
+// Create a SLIP10Node from a derivation path. You can also specify a key and depth instead.
+const node = await SLIP10Node.fromDerivationPath({
+  curve: 'secp256k1',
+  derivationPath: [`bip39:${secretRecoveryPhrase}`, `slip10:0'`],
+});
+
+// SLIP-10 supports Ed25519 as well.
+const ed25519Node = await SLIP10Node.fromDerivationPath({
+  curve: 'ed25519',
+  derivationPath: [`bip39:${secretRecoveryPhrase}`, `slip10:0'`],
+});
+
+// Derive the child node at m / 0' / 1' / 2'. This results in a new SLIP10Node.
+// Note that you cannot derive unhardened child nodes when using Ed25519.
+const childNode = await node.derive([`slip10:1'`, `slip10:2'`]);
+```
+
+The `SLIP10Node` class supports both `bip32:` and `slip10:` paths. While [BIP-32] and [SLIP-10] are mostly compatible with
+each other, there are some differences:
+
+- Ed25519 is only supported by [SLIP-10], so you must use `slip10:` paths when deriving Ed25519 keys.
+- Key derivation errors (i.e., invalid keys being derived) are handled slightly different. While the chance of
+  encountering such an error is extremely low, it is possible.
+
+If you require full compatibility with one or the other, you can choose between the `bip32:` and `slip10:` path types.
+
+There are other ways of deriving keys in addition to the above example.
+See the docstrings in the [BIP44Node](./src/BIP44Node.ts), [BIP44CoinTypeNode](./src/BIP44CoinTypeNode.ts) and
+[SLIP10Node](./src/SLIP10Node.ts) files for details.
+
+### Internals
+
+This package also has methods for deriving arbitrary [SLIP-10] and [BIP-32] keys, and generating seeds from [BIP-39]
+secret recovery phrases.
+These methods do not constitute a safe key derivation API, and their use is **strongly discouraged**.
+Nevertheless, since those methods were the main exports of this package prior to version `3.0.0`, consumers can
+still access them by importing `@metamask/key-tree/derivation`.
+
+## Security
+
+This package is rigorously tested against reference implementations and the [SLIP-10] and [BIP-32] specifications.
+See the [reference implementation tests](tests/reference-implementations.test.ts) for details.
+
+## Further Reading
+
+- [BIP-32]
+- [BIP-39]
+- [BIP-44]
+- [SLIP-10]
+- [SLIP-44]
+- Network Working Group: ["Key Derivation Functions and their Uses"](https://trac.tools.ietf.org/html/draft-irtf-cfrg-kdf-uses-00)
+
+## Contributing
+
+This package is part of a monorepo. Instructions for contributing can be found in the [monorepo README](https://github.com/MetaMask/core#readme).
+
+[bip-32]: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+[bip-39]: https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
+[bip-44]: https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
+[slip-10]: https://github.com/satoshilabs/slips/blob/master/slip-0010.md
+[slip-44]: https://github.com/satoshilabs/slips/blob/master/slip-0044.md

package/dist/BIP44CoinTypeNode.d.ts

@@ -0,0 +1,244 @@
+import type { BIP44NodeInterface, JsonBIP44Node } from './BIP44Node.js';
+import { BIP44Node } from './BIP44Node.js';
+import type { BIP39Node, BIP44Depth, BIP44PurposeNodeToken, CoinTypeHDPathString, HardenedBIP32Node, Network } from './constants.js';
+import type { CryptographicFunctions } from './cryptography.js';
+import type { SupportedCurve } from './curves/index.js';
+import type { CoinTypeToAddressIndices } from './utils.js';
+import { getBIP44ChangePathString } from './utils.js';
+export type CoinTypeHDPathTuple = [
+    BIP39Node,
+    typeof BIP44PurposeNodeToken,
+    HardenedBIP32Node
+];
+export type CoinTypeSeedPathTuple = [
+    Uint8Array,
+    typeof BIP44PurposeNodeToken,
+    HardenedBIP32Node
+];
+export declare const BIP_44_COIN_TYPE_DEPTH = 2;
+export type JsonBIP44CoinTypeNode = JsonBIP44Node & {
+    readonly coin_type: number;
+    readonly path: CoinTypeHDPathString;
+};
+export type BIP44CoinTypeNodeInterface = BIP44NodeInterface & {
+    readonly coin_type: number;
+    readonly path: CoinTypeHDPathString;
+};
+export type BIP44CoinTypeSeedOptions = {
+    readonly derivationPath: CoinTypeSeedPathTuple;
+    readonly network?: Network | undefined;
+};
+/**
+ * A wrapper object for BIP-44 `coin_type` keys. `coin_type` is the index
+ * specifying the protocol for which deeper keys are intended. For the
+ * authoritative list of coin types, please see
+ * [SLIP-44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).
+ *
+ * Recall that a BIP-44 HD tree path consists of the following nodes:
+ *
+ * `m / 44' / coin_type' / account' / change / address_index`
+ *
+ * With the following depths:
+ *
+ * `0 / 1 / 2 / 3 / 4 / 5`
+ *
+ */
+export declare class BIP44CoinTypeNode implements BIP44CoinTypeNodeInterface {
+    #private;
+    /**
+     * Constructs a BIP-44 `coin_type` node. `coin_type` is the index
+     * specifying the protocol for which deeper keys are intended. For the
+     * authoritative list of coin types, please see
+     * [SLIP-44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).
+     *
+     * Recall that a BIP-44 HD tree path consists of the following nodes:
+     *
+     * `m / 44' / coin_type' / account' / change / address_index`
+     *
+     * With the following depths:
+     *
+     * `0 / 1 / 2 / 3 / 4 / 5`
+     *
+     * @param json - The {@link JsonBIP44Node} for the key of this node.
+     * @param coin_type - The coin_type index of this node. Must be a non-negative
+     * integer.
+     * @param cryptographicFunctions - The cryptographic functions to use. If
+     * provided, these will be used instead of the built-in implementations.
+     * @returns A BIP44CoinType node.
+     */
+    static fromJSON(json: JsonBIP44Node, coin_type: number, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44CoinTypeNode>;
+    /**
+     * Construct a BIP-44 `coin_type` node. `coin_type` is the index
+     * specifying the protocol for which deeper keys are intended. For the
+     * authoritative list of coin types, please see
+     * [SLIP-44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).
+     *
+     * Recall that a BIP-44 HD tree path consists of the following nodes:
+     *
+     * `m / 44' / coin_type' / account' / change / address_index`
+     *
+     * With the following depths:
+     *
+     * `0 / 1 / 2 / 3 / 4 / 5`
+     *
+     * @param derivationPath - The derivation path for the key of this node.
+     * @param network - The network for the node. This is only used for extended
+     * keys, and defaults to `mainnet`.
+     * @param cryptographicFunctions - The cryptographic functions to use. If
+     * provided, these will be used instead of the built-in implementations.
+     * @returns A BIP44CoinType node.
+     */
+    static fromDerivationPath(derivationPath: CoinTypeHDPathTuple, network?: Network | undefined, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44CoinTypeNode>;
+    /**
+     * Create a new BIP-44 coin type node from a BIP-39 seed. The derivation path
+     * must be rooted, i.e. it must begin with a BIP-39 node, given as a
+     * `Uint8Array` of the seed bytes.
+     *
+     * All parameters are stringently validated, and an error is thrown if
+     * validation fails.
+     *
+     * @param options - The options for the new node.
+     * @param options.derivationPath - The rooted HD tree path that will be used
+     * to derive the key of this node.
+     * @param options.network - The network for the node. This is only used for
+     * extended keys, and defaults to `mainnet`.
+     * @param cryptographicFunctions - The cryptographic functions to use. If
+     * provided, these will be used instead of the built-in implementations.
+     * @returns A new BIP-44 node.
+     */
+    static fromSeed({ derivationPath, network }: BIP44CoinTypeSeedOptions, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44CoinTypeNode>;
+    /**
+     * Constructs a BIP-44 `coin_type` node. `coin_type` is the index
+     * specifying the protocol for which deeper keys are intended. For the
+     * authoritative list of coin types, please see
+     * [SLIP-44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).
+     *
+     * Recall that a BIP-44 HD tree path consists of the following nodes:
+     *
+     * `m / 44' / coin_type' / account' / change / address_index`
+     *
+     * With the following depths:
+     *
+     * `0 / 1 / 2 / 3 / 4 / 5`
+     *
+     * @param node - The {@link BIP44Node} for the key of this node.
+     * @param coin_type - The coin_type index of this node. Must be a non-negative
+     * integer.
+     * @returns A BIP44CoinType node.
+     */
+    static fromNode(node: BIP44Node, coin_type: number): Promise<BIP44CoinTypeNode>;
+    readonly path: CoinTypeHDPathString;
+    readonly coin_type: number;
+    private constructor();
+    get depth(): BIP44Depth;
+    get privateKeyBytes(): Uint8Array | undefined;
+    get publicKeyBytes(): Uint8Array;
+    get chainCodeBytes(): Uint8Array;
+    get privateKey(): string | undefined;
+    get publicKey(): string;
+    get compressedPublicKey(): string;
+    get compressedPublicKeyBytes(): Uint8Array;
+    get chainCode(): string;
+    get address(): string;
+    get masterFingerprint(): number | undefined;
+    get parentFingerprint(): number;
+    get fingerprint(): number;
+    get index(): number;
+    get network(): Network;
+    get curve(): SupportedCurve;
+    get extendedKey(): string;
+    /**
+     * Derives a BIP-44 `address_index` key corresponding to the path of this
+     * node and the specified `account`, `change`, and `address_index` values.
+     * `address_index` keys are normally the keys used to generate user account
+     * addresses.
+     *
+     * Recall that a BIP-44 HD tree path consists of the following nodes:
+     *
+     * `m / 44' / coin_type' / account' / change / address_index`
+     *
+     * With the following depths:
+     *
+     * `0 / 1 / 2 / 3 / 4 / 5`
+     *
+     * @param indices - The BIP-44 index values to use in key derivation.
+     * @param indices.account - The `account` index. Default: `0`
+     * @param indices.change - The `change` index. Default: `0`
+     * @param indices.address_index - The `address_index` index.
+     * @returns The derived BIP-44 `address_index` node.
+     */
+    deriveBIP44AddressKey({ account, change, address_index, }: CoinTypeToAddressIndices): Promise<BIP44Node>;
+    toJSON(): JsonBIP44CoinTypeNode;
+}
+/**
+ * Derives a BIP-44 address key corresponding to the specified derivation path,
+ * given either by a {@link BIP44CoinTypeNode} or derivation path tuple.
+ *
+ * Recall that a BIP-44 HD tree path consists of the following nodes:
+ *
+ * `m / 44' / coin_type' / account' / change / address_index`
+ *
+ * With the following depths:
+ *
+ * `0 / 1 / 2 / 3 / 4 / 5`
+ *
+ * @param parentKeyOrNode - The `coin_type` parent key to derive from.
+ * @param indices - The BIP-44 index values to use in key derivation.
+ * @param indices.account - The `account` index. Default: `0`.
+ * @param indices.change - The `change` index. Default: `0`.
+ * @param indices.address_index - The `address_index` index.
+ * @param cryptographicFunctions - The cryptographic functions to use. If
+ * provided, these will be used instead of the built-in implementations.
+ * @returns The derived `address_index` key for the specified derivation path.
+ */
+export declare function deriveBIP44AddressKey(parentKeyOrNode: BIP44CoinTypeNode | JsonBIP44CoinTypeNode | string, { account, change, address_index }: CoinTypeToAddressIndices, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44Node>;
+export type BIP44AddressKeyDeriver = {
+    /**
+     * @param address_index - The `address_index` value.
+     * @param isHardened - Whether the derived index is hardened.
+     * @returns The key corresponding to the path of this deriver and the
+     * specified `address_index` value.
+     */
+    (address_index: number, isHardened?: boolean): Promise<BIP44Node>;
+    /**
+     * A human-readable representation of the derivation path of this deriver
+     * function, excluding the `address_index`, which is parameterized.
+     *
+     * Recall that a BIP-44 HD tree path consists of the following nodes:
+     *
+     * `m / 44' / coin_type' / account' / change / address_index`
+     *
+     * With the following depths:
+     *
+     * `0 / 1 / 2 / 3 / 4 / 5`
+     */
+    path: ReturnType<typeof getBIP44ChangePathString>;
+    /**
+     * The `coin_type` index of addresses derived by this deriver function.
+     */
+    coin_type: number;
+};
+/**
+ * Creates a function that derives BIP-44 address keys corresponding to the
+ * specified derivation path, given either by a {@link BIP44CoinTypeNode} or
+ * derivation path tuple.
+ *
+ * Recall that a BIP-44 HD tree path consists of the following nodes:
+ *
+ * `m / 44' / coin_type' / account' / change / address_index`
+ *
+ * With the following depths:
+ *
+ * `0 / 1 / 2 / 3 / 4 / 5`
+ *
+ * @param node - The {@link BIP44CoinTypeNode} to derive address keys from.
+ * This node contains a BIP-44 key of depth 2, `coin_type`.
+ * @param accountAndChangeIndices - The `account` and `change` indices that
+ * will be used to derive addresses.
+ * @param cryptographicFunctions - The cryptographic functions to use. If
+ * provided, these will be used instead of the built-in implementations.
+ * @returns The deriver function for the derivation path specified by the
+ * `coin_type` node, `account`, and `change` indices.
+ */
+export declare function getBIP44AddressKeyDeriver(node: BIP44CoinTypeNode | JsonBIP44CoinTypeNode | string, accountAndChangeIndices?: Omit<CoinTypeToAddressIndices, 'address_index'>, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44AddressKeyDeriver>;
+//# sourceMappingURL=BIP44CoinTypeNode.d.ts.map

package/dist/BIP44CoinTypeNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BIP44CoinTypeNode.d.ts","sourceRoot":"","sources":["../src/BIP44CoinTypeNode.ts"],"names":[],"mappings":"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"}