@metamask-previews/key-tree 0.0.0-stage → 10.1.1-preview-2ad7fb9

package/dist/BIP44CoinTypeNode.js

@@ -0,0 +1,365 @@
+import { BIP44Node } from './BIP44Node.js';
+import { BIP_32_HARDENED_OFFSET } from './constants.js';
+import { deriveChildNode } from './SLIP10Node.js';
+import { getBIP44CoinType, getBIP32NodeToken, getBIP44ChangePathString, getBIP44CoinTypePathString, getBIP44CoinTypeToAddressPathTuple, getHardenedBIP32NodeToken, getUnhardenedBIP32NodeToken, hexStringToBytes, nullableHexStringToBytes, } from './utils.js';
+export const BIP_44_COIN_TYPE_DEPTH = 2;
+/**
+ * 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 class 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 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 async fromJSON(json, coin_type, cryptographicFunctions) {
+        validateCoinType(coin_type);
+        validateCoinTypeNodeDepth(json.depth);
+        const node = await BIP44Node.fromExtendedKey({
+            depth: json.depth,
+            index: json.index,
+            network: json.network,
+            parentFingerprint: json.parentFingerprint,
+            chainCode: hexStringToBytes(json.chainCode),
+            privateKey: nullableHexStringToBytes(json.privateKey),
+            publicKey: hexStringToBytes(json.publicKey),
+        }, cryptographicFunctions);
+        return new BIP44CoinTypeNode(node, coin_type);
+    }
+    /**
+     * 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 async fromDerivationPath(derivationPath, network, cryptographicFunctions) {
+        validateCoinTypeNodeDepth(derivationPath.length - 1);
+        const node = await BIP44Node.fromDerivationPath({
+            derivationPath,
+            network,
+        }, cryptographicFunctions);
+        const coinType = getBIP44CoinType(derivationPath);
+        return new BIP44CoinTypeNode(node, coinType);
+    }
+    /**
+     * 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 async fromSeed({ derivationPath, network }, cryptographicFunctions) {
+        validateCoinTypeNodeDepth(derivationPath.length - 1);
+        const node = await BIP44Node.fromSeed({
+            derivationPath,
+            network,
+        }, cryptographicFunctions);
+        const coinType = getBIP44CoinType(derivationPath);
+        return new BIP44CoinTypeNode(node, coinType);
+    }
+    /**
+     * 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 async fromNode(node, coin_type) {
+        if (!(node instanceof BIP44Node)) {
+            throw new Error('Invalid node: Expected an instance of BIP44Node.');
+        }
+        validateCoinType(coin_type);
+        validateCoinTypeNodeDepth(node.depth);
+        // TODO: Make this function not async in a future version.
+        return Promise.resolve(new BIP44CoinTypeNode(node, coin_type));
+    }
+    #node;
+    path;
+    coin_type;
+    // Constructors cannot use hash names.
+    // eslint-disable-next-line no-restricted-syntax
+    constructor(node, coin_type) {
+        this.#node = node;
+        this.coin_type = coin_type;
+        this.path = getBIP44CoinTypePathString(coin_type);
+        Object.freeze(this);
+    }
+    get depth() {
+        return this.#node.depth;
+    }
+    get privateKeyBytes() {
+        return this.#node.privateKeyBytes;
+    }
+    get publicKeyBytes() {
+        return this.#node.publicKeyBytes;
+    }
+    get chainCodeBytes() {
+        return this.#node.chainCodeBytes;
+    }
+    get privateKey() {
+        return this.#node.privateKey;
+    }
+    get publicKey() {
+        return this.#node.publicKey;
+    }
+    get compressedPublicKey() {
+        return this.#node.compressedPublicKey;
+    }
+    get compressedPublicKeyBytes() {
+        return this.#node.compressedPublicKeyBytes;
+    }
+    get chainCode() {
+        return this.#node.chainCode;
+    }
+    get address() {
+        return this.#node.address;
+    }
+    get masterFingerprint() {
+        return this.#node.masterFingerprint;
+    }
+    get parentFingerprint() {
+        return this.#node.parentFingerprint;
+    }
+    get fingerprint() {
+        return this.#node.fingerprint;
+    }
+    get index() {
+        return this.#node.index;
+    }
+    get network() {
+        return this.#node.network;
+    }
+    get curve() {
+        return this.#node.curve;
+    }
+    get extendedKey() {
+        return this.#node.extendedKey;
+    }
+    /**
+     * 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.
+     */
+    async deriveBIP44AddressKey({ account = 0, change = 0, address_index, }) {
+        return await this.#node.derive(getBIP44CoinTypeToAddressPathTuple({ account, change, address_index }));
+    }
+    toJSON() {
+        return {
+            ...this.#node.toJSON(),
+            coin_type: this.coin_type,
+            path: this.path,
+        };
+    }
+}
+/**
+ * Validates the depth of a `coin_type` node. Simply, ensures that it is the
+ * number `2`. An error is thrown if validation fails.
+ *
+ * @param depth - The depth to validate.
+ */
+function validateCoinTypeNodeDepth(depth) {
+    if (depth !== BIP_44_COIN_TYPE_DEPTH) {
+        throw new Error(`Invalid depth: Coin type nodes must be of depth ${BIP_44_COIN_TYPE_DEPTH}. Received: "${depth}"`);
+    }
+}
+/**
+ * Validates that the coin type is a non-negative integer number. An error is
+ * thrown if validation fails.
+ *
+ * @param coin_type - The coin type to validate.
+ */
+function validateCoinType(coin_type) {
+    if (typeof coin_type !== 'number' ||
+        !Number.isInteger(coin_type) ||
+        coin_type < 0) {
+        throw new Error('Invalid coin type: The specified coin type must be a non-negative integer number.');
+    }
+}
+/**
+ * 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 async function deriveBIP44AddressKey(parentKeyOrNode, { account = 0, change = 0, address_index }, cryptographicFunctions) {
+    const path = getBIP44CoinTypeToAddressPathTuple({
+        account,
+        change,
+        address_index,
+    });
+    const node = await getNode(parentKeyOrNode, cryptographicFunctions);
+    const childNode = await deriveChildNode({
+        path,
+        node,
+    }, cryptographicFunctions);
+    return new BIP44Node(childNode);
+}
+/**
+ * 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 async function getBIP44AddressKeyDeriver(node, accountAndChangeIndices, cryptographicFunctions) {
+    const { account = 0, change = 0 } = accountAndChangeIndices ?? {};
+    const actualNode = await getNode(node, cryptographicFunctions);
+    const accountNode = getHardenedBIP32NodeToken(account);
+    const changeNode = getBIP32NodeToken(change);
+    const bip44AddressKeyDeriver = async (address_index, isHardened = false) => {
+        const slip10Node = await deriveChildNode({
+            path: [
+                accountNode,
+                changeNode,
+                isHardened
+                    ? getHardenedBIP32NodeToken(address_index)
+                    : getUnhardenedBIP32NodeToken(address_index),
+            ],
+            node: actualNode,
+        }, cryptographicFunctions);
+        return new BIP44Node(slip10Node);
+    };
+    bip44AddressKeyDeriver.coin_type = actualNode.coin_type;
+    bip44AddressKeyDeriver.path = getBIP44ChangePathString(actualNode.path, {
+        account,
+        change,
+    });
+    Object.freeze(bip44AddressKeyDeriver);
+    return bip44AddressKeyDeriver;
+}
+/**
+ * Get a BIP-44 coin type node from a JSON node or extended key string. If an existing coin type
+ * node is provided, the same node is returned.
+ *
+ * The depth of the node is validated to be a valid coin type node.
+ *
+ * @param node - A BIP-44 coin type node, JSON node or extended key.
+ * @param cryptographicFunctions - The cryptographic functions to use. If
+ * provided, these will be used instead of the built-in implementations. This is
+ * only used if the node is an extended key string or JSON object.
+ * @returns A BIP44CoinType node.
+ */
+async function getNode(node, cryptographicFunctions) {
+    if (node instanceof BIP44CoinTypeNode) {
+        validateCoinTypeNodeDepth(node.depth);
+        return node;
+    }
+    if (typeof node === 'string') {
+        const bip44Node = await BIP44Node.fromExtendedKey(node, cryptographicFunctions);
+        const coinTypeNode = await BIP44CoinTypeNode.fromNode(bip44Node, bip44Node.index - BIP_32_HARDENED_OFFSET);
+        validateCoinTypeNodeDepth(coinTypeNode.depth);
+        return coinTypeNode;
+    }
+    return BIP44CoinTypeNode.fromJSON(node, node.coin_type, cryptographicFunctions);
+}
+//# sourceMappingURL=BIP44CoinTypeNode.js.map

package/dist/BIP44CoinTypeNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BIP44CoinTypeNode.js","sourceRoot":"","sources":["../src/BIP44CoinTypeNode.ts"],"names":[],"mappings":"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","sourcesContent":["import type { BIP44NodeInterface, JsonBIP44Node } from './BIP44Node.js';\nimport { BIP44Node } from './BIP44Node.js';\nimport type {\n  BIP39Node,\n  BIP44Depth,\n  BIP44PurposeNodeToken,\n  CoinTypeHDPathString,\n  HardenedBIP32Node,\n  Network,\n} from './constants.js';\nimport { BIP_32_HARDENED_OFFSET } from './constants.js';\nimport type { CryptographicFunctions } from './cryptography.js';\nimport type { SupportedCurve } from './curves/index.js';\nimport { deriveChildNode } from './SLIP10Node.js';\nimport type { CoinTypeToAddressIndices } from './utils.js';\nimport {\n  getBIP44CoinType,\n  getBIP32NodeToken,\n  getBIP44ChangePathString,\n  getBIP44CoinTypePathString,\n  getBIP44CoinTypeToAddressPathTuple,\n  getHardenedBIP32NodeToken,\n  getUnhardenedBIP32NodeToken,\n  hexStringToBytes,\n  nullableHexStringToBytes,\n} from './utils.js';\n\nexport type CoinTypeHDPathTuple = [\n  BIP39Node,\n  typeof BIP44PurposeNodeToken,\n  HardenedBIP32Node,\n];\n\nexport type CoinTypeSeedPathTuple = [\n  Uint8Array,\n  typeof BIP44PurposeNodeToken,\n  HardenedBIP32Node,\n];\n\nexport const BIP_44_COIN_TYPE_DEPTH = 2;\n\nexport type JsonBIP44CoinTypeNode = JsonBIP44Node & {\n  readonly coin_type: number;\n  readonly path: CoinTypeHDPathString;\n};\n\nexport type BIP44CoinTypeNodeInterface = BIP44NodeInterface & {\n  readonly coin_type: number;\n  readonly path: CoinTypeHDPathString;\n};\n\nexport type BIP44CoinTypeSeedOptions = {\n  readonly derivationPath: CoinTypeSeedPathTuple;\n  readonly network?: Network | undefined;\n};\n\n/**\n * A wrapper object for BIP-44 `coin_type` keys. `coin_type` is the index\n * specifying the protocol for which deeper keys are intended. For the\n * authoritative list of coin types, please see\n * [SLIP-44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).\n *\n * Recall that a BIP-44 HD tree path consists of the following nodes:\n *\n * `m / 44' / coin_type' / account' / change / address_index`\n *\n * With the following depths:\n *\n * `0 / 1 / 2 / 3 / 4 / 5`\n *\n */\nexport class BIP44CoinTypeNode implements BIP44CoinTypeNodeInterface {\n  /**\n   * Constructs a BIP-44 `coin_type` node. `coin_type` is the index\n   * specifying the protocol for which deeper keys are intended. For the\n   * authoritative list of coin types, please see\n   * [SLIP-44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).\n   *\n   * Recall that a BIP-44 HD tree path consists of the following nodes:\n   *\n   * `m / 44' / coin_type' / account' / change / address_index`\n   *\n   * With the following depths:\n   *\n   * `0 / 1 / 2 / 3 / 4 / 5`\n   *\n   * @param json - The {@link JsonBIP44Node} for the key of this node.\n   * @param coin_type - The coin_type index of this node. Must be a non-negative\n   * integer.\n   * @param cryptographicFunctions - The cryptographic functions to use. If\n   * provided, these will be used instead of the built-in implementations.\n   * @returns A BIP44CoinType node.\n   */\n  static async fromJSON(\n    json: JsonBIP44Node,\n    coin_type: number,\n    cryptographicFunctions?: CryptographicFunctions,\n  ): Promise<BIP44CoinTypeNode> {\n    validateCoinType(coin_type);\n    validateCoinTypeNodeDepth(json.depth);\n\n    const node = await BIP44Node.fromExtendedKey(\n      {\n        depth: json.depth,\n        index: json.index,\n        network: json.network,\n        parentFingerprint: json.parentFingerprint,\n        chainCode: hexStringToBytes(json.chainCode),\n        privateKey: nullableHexStringToBytes(json.privateKey),\n        publicKey: hexStringToBytes(json.publicKey),\n      },\n      cryptographicFunctions,\n    );\n\n    return new BIP44CoinTypeNode(node, coin_type);\n  }\n\n  /**\n   * Construct a BIP-44 `coin_type` node. `coin_type` is the index\n   * specifying the protocol for which deeper keys are intended. For the\n   * authoritative list of coin types, please see\n   * [SLIP-44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).\n   *\n   * Recall that a BIP-44 HD tree path consists of the following nodes:\n   *\n   * `m / 44' / coin_type' / account' / change / address_index`\n   *\n   * With the following depths:\n   *\n   * `0 / 1 / 2 / 3 / 4 / 5`\n   *\n   * @param derivationPath - The derivation path for the key of this node.\n   * @param network - The network for the node. This is only used for extended\n   * keys, and defaults to `mainnet`.\n   * @param cryptographicFunctions - The cryptographic functions to use. If\n   * provided, these will be used instead of the built-in implementations.\n   * @returns A BIP44CoinType node.\n   */\n  static async fromDerivationPath(\n    derivationPath: CoinTypeHDPathTuple,\n    network?: Network | undefined,\n    cryptographicFunctions?: CryptographicFunctions,\n  ): Promise<BIP44CoinTypeNode> {\n    validateCoinTypeNodeDepth(derivationPath.length - 1);\n\n    const node = await BIP44Node.fromDerivationPath(\n      {\n        derivationPath,\n        network,\n      },\n      cryptographicFunctions,\n    );\n\n    const coinType = getBIP44CoinType(derivationPath);\n    return new BIP44CoinTypeNode(node, coinType);\n  }\n\n  /**\n   * Create a new BIP-44 coin type node from a BIP-39 seed. The derivation path\n   * must be rooted, i.e. it must begin with a BIP-39 node, given as a\n   * `Uint8Array` of the seed bytes.\n   *\n   * All parameters are stringently validated, and an error is thrown if\n   * validation fails.\n   *\n   * @param options - The options for the new node.\n   * @param options.derivationPath - The rooted HD tree path that will be used\n   * to derive the key of this node.\n   * @param options.network - The network for the node. This is only used for\n   * extended keys, and defaults to `mainnet`.\n   * @param cryptographicFunctions - The cryptographic functions to use. If\n   * provided, these will be used instead of the built-in implementations.\n   * @returns A new BIP-44 node.\n   */\n  static async fromSeed(\n    { derivationPath, network }: BIP44CoinTypeSeedOptions,\n    cryptographicFunctions?: CryptographicFunctions,\n  ): Promise<BIP44CoinTypeNode> {\n    validateCoinTypeNodeDepth(derivationPath.length - 1);\n\n    const node = await BIP44Node.fromSeed(\n      {\n        derivationPath,\n        network,\n      },\n      cryptographicFunctions,\n    );\n\n    const coinType = getBIP44CoinType(derivationPath);\n    return new BIP44CoinTypeNode(node, coinType);\n  }\n\n  /**\n   * Constructs a BIP-44 `coin_type` node. `coin_type` is the index\n   * specifying the protocol for which deeper keys are intended. For the\n   * authoritative list of coin types, please see\n   * [SLIP-44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md).\n   *\n   * Recall that a BIP-44 HD tree path consists of the following nodes:\n   *\n   * `m / 44' / coin_type' / account' / change / address_index`\n   *\n   * With the following depths:\n   *\n   * `0 / 1 / 2 / 3 / 4 / 5`\n   *\n   * @param node - The {@link BIP44Node} for the key of this node.\n   * @param coin_type - The coin_type index of this node. Must be a non-negative\n   * integer.\n   * @returns A BIP44CoinType node.\n   */\n  static async fromNode(\n    node: BIP44Node,\n    coin_type: number,\n  ): Promise<BIP44CoinTypeNode> {\n    if (!(node instanceof BIP44Node)) {\n      throw new Error('Invalid node: Expected an instance of BIP44Node.');\n    }\n\n    validateCoinType(coin_type);\n    validateCoinTypeNodeDepth(node.depth);\n\n    // TODO: Make this function not async in a future version.\n    return Promise.resolve(new BIP44CoinTypeNode(node, coin_type));\n  }\n\n  readonly #node: BIP44Node;\n\n  public readonly path: CoinTypeHDPathString;\n\n  public readonly coin_type: number;\n\n  // Constructors cannot use hash names.\n  // eslint-disable-next-line no-restricted-syntax\n  private constructor(node: BIP44Node, coin_type: number) {\n    this.#node = node;\n    this.coin_type = coin_type;\n    this.path = getBIP44CoinTypePathString(coin_type);\n\n    Object.freeze(this);\n  }\n\n  public get depth(): BIP44Depth {\n    return this.#node.depth;\n  }\n\n  public get privateKeyBytes(): Uint8Array | undefined {\n    return this.#node.privateKeyBytes;\n  }\n\n  public get publicKeyBytes(): Uint8Array {\n    return this.#node.publicKeyBytes;\n  }\n\n  public get chainCodeBytes(): Uint8Array {\n    return this.#node.chainCodeBytes;\n  }\n\n  public get privateKey(): string | undefined {\n    return this.#node.privateKey;\n  }\n\n  public get publicKey(): string {\n    return this.#node.publicKey;\n  }\n\n  public get compressedPublicKey(): string {\n    return this.#node.compressedPublicKey;\n  }\n\n  public get compressedPublicKeyBytes(): Uint8Array {\n    return this.#node.compressedPublicKeyBytes;\n  }\n\n  public get chainCode(): string {\n    return this.#node.chainCode;\n  }\n\n  public get address(): string {\n    return this.#node.address;\n  }\n\n  public get masterFingerprint(): number | undefined {\n    return this.#node.masterFingerprint;\n  }\n\n  public get parentFingerprint(): number {\n    return this.#node.parentFingerprint;\n  }\n\n  public get fingerprint(): number {\n    return this.#node.fingerprint;\n  }\n\n  public get index(): number {\n    return this.#node.index;\n  }\n\n  public get network(): Network {\n    return this.#node.network;\n  }\n\n  public get curve(): SupportedCurve {\n    return this.#node.curve;\n  }\n\n  public get extendedKey(): string {\n    return this.#node.extendedKey;\n  }\n\n  /**\n   * Derives a BIP-44 `address_index` key corresponding to the path of this\n   * node and the specified `account`, `change`, and `address_index` values.\n   * `address_index` keys are normally the keys used to generate user account\n   * addresses.\n   *\n   * Recall that a BIP-44 HD tree path consists of the following nodes:\n   *\n   * `m / 44' / coin_type' / account' / change / address_index`\n   *\n   * With the following depths:\n   *\n   * `0 / 1 / 2 / 3 / 4 / 5`\n   *\n   * @param indices - The BIP-44 index values to use in key derivation.\n   * @param indices.account - The `account` index. Default: `0`\n   * @param indices.change - The `change` index. Default: `0`\n   * @param indices.address_index - The `address_index` index.\n   * @returns The derived BIP-44 `address_index` node.\n   */\n  async deriveBIP44AddressKey({\n    account = 0,\n    change = 0,\n    address_index,\n  }: CoinTypeToAddressIndices): Promise<BIP44Node> {\n    return await this.#node.derive(\n      getBIP44CoinTypeToAddressPathTuple({ account, change, address_index }),\n    );\n  }\n\n  toJSON(): JsonBIP44CoinTypeNode {\n    return {\n      ...this.#node.toJSON(),\n      coin_type: this.coin_type,\n      path: this.path,\n    };\n  }\n}\n\n/**\n * Validates the depth of a `coin_type` node. Simply, ensures that it is the\n * number `2`. An error is thrown if validation fails.\n *\n * @param depth - The depth to validate.\n */\nfunction validateCoinTypeNodeDepth(depth: number): void {\n  if (depth !== BIP_44_COIN_TYPE_DEPTH) {\n    throw new Error(\n      `Invalid depth: Coin type nodes must be of depth ${BIP_44_COIN_TYPE_DEPTH}. Received: \"${depth}\"`,\n    );\n  }\n}\n\n/**\n * Validates that the coin type is a non-negative integer number. An error is\n * thrown if validation fails.\n *\n * @param coin_type - The coin type to validate.\n */\nfunction validateCoinType(coin_type: unknown): asserts coin_type is number {\n  if (\n    typeof coin_type !== 'number' ||\n    !Number.isInteger(coin_type) ||\n    coin_type < 0\n  ) {\n    throw new Error(\n      'Invalid coin type: The specified coin type must be a non-negative integer number.',\n    );\n  }\n}\n\n/**\n * Derives a BIP-44 address key corresponding to the specified derivation path,\n * given either by a {@link BIP44CoinTypeNode} or derivation path tuple.\n *\n * Recall that a BIP-44 HD tree path consists of the following nodes:\n *\n * `m / 44' / coin_type' / account' / change / address_index`\n *\n * With the following depths:\n *\n * `0 / 1 / 2 / 3 / 4 / 5`\n *\n * @param parentKeyOrNode - The `coin_type` parent key to derive from.\n * @param indices - The BIP-44 index values to use in key derivation.\n * @param indices.account - The `account` index. Default: `0`.\n * @param indices.change - The `change` index. Default: `0`.\n * @param indices.address_index - The `address_index` index.\n * @param cryptographicFunctions - The cryptographic functions to use. If\n * provided, these will be used instead of the built-in implementations.\n * @returns The derived `address_index` key for the specified derivation path.\n */\nexport async function deriveBIP44AddressKey(\n  parentKeyOrNode: BIP44CoinTypeNode | JsonBIP44CoinTypeNode | string,\n  { account = 0, change = 0, address_index }: CoinTypeToAddressIndices,\n  cryptographicFunctions?: CryptographicFunctions,\n): Promise<BIP44Node> {\n  const path = getBIP44CoinTypeToAddressPathTuple({\n    account,\n    change,\n    address_index,\n  });\n\n  const node = await getNode(parentKeyOrNode, cryptographicFunctions);\n  const childNode = await deriveChildNode(\n    {\n      path,\n      node,\n    },\n    cryptographicFunctions,\n  );\n\n  return new BIP44Node(childNode);\n}\n\nexport type BIP44AddressKeyDeriver = {\n  /**\n   * @param address_index - The `address_index` value.\n   * @param isHardened - Whether the derived index is hardened.\n   * @returns The key corresponding to the path of this deriver and the\n   * specified `address_index` value.\n   */\n  (address_index: number, isHardened?: boolean): Promise<BIP44Node>;\n\n  /**\n   * A human-readable representation of the derivation path of this deriver\n   * function, excluding the `address_index`, which is parameterized.\n   *\n   * Recall that a BIP-44 HD tree path consists of the following nodes:\n   *\n   * `m / 44' / coin_type' / account' / change / address_index`\n   *\n   * With the following depths:\n   *\n   * `0 / 1 / 2 / 3 / 4 / 5`\n   */\n  path: ReturnType<typeof getBIP44ChangePathString>;\n\n  /**\n   * The `coin_type` index of addresses derived by this deriver function.\n   */\n  coin_type: number;\n};\n\n/**\n * Creates a function that derives BIP-44 address keys corresponding to the\n * specified derivation path, given either by a {@link BIP44CoinTypeNode} or\n * derivation path tuple.\n *\n * Recall that a BIP-44 HD tree path consists of the following nodes:\n *\n * `m / 44' / coin_type' / account' / change / address_index`\n *\n * With the following depths:\n *\n * `0 / 1 / 2 / 3 / 4 / 5`\n *\n * @param node - The {@link BIP44CoinTypeNode} to derive address keys from.\n * This node contains a BIP-44 key of depth 2, `coin_type`.\n * @param accountAndChangeIndices - The `account` and `change` indices that\n * will be used to derive addresses.\n * @param cryptographicFunctions - The cryptographic functions to use. If\n * provided, these will be used instead of the built-in implementations.\n * @returns The deriver function for the derivation path specified by the\n * `coin_type` node, `account`, and `change` indices.\n */\nexport async function getBIP44AddressKeyDeriver(\n  node: BIP44CoinTypeNode | JsonBIP44CoinTypeNode | string,\n  accountAndChangeIndices?: Omit<CoinTypeToAddressIndices, 'address_index'>,\n  cryptographicFunctions?: CryptographicFunctions,\n): Promise<BIP44AddressKeyDeriver> {\n  const { account = 0, change = 0 } = accountAndChangeIndices ?? {};\n\n  const actualNode = await getNode(node, cryptographicFunctions);\n\n  const accountNode = getHardenedBIP32NodeToken(account);\n  const changeNode = getBIP32NodeToken(change);\n\n  const bip44AddressKeyDeriver: BIP44AddressKeyDeriver = async (\n    address_index: number,\n    isHardened = false,\n  ): Promise<BIP44Node> => {\n    const slip10Node = await deriveChildNode(\n      {\n        path: [\n          accountNode,\n          changeNode,\n          isHardened\n            ? getHardenedBIP32NodeToken(address_index)\n            : getUnhardenedBIP32NodeToken(address_index),\n        ],\n        node: actualNode,\n      },\n      cryptographicFunctions,\n    );\n\n    return new BIP44Node(slip10Node);\n  };\n\n  bip44AddressKeyDeriver.coin_type = actualNode.coin_type;\n  bip44AddressKeyDeriver.path = getBIP44ChangePathString(actualNode.path, {\n    account,\n    change,\n  });\n\n  Object.freeze(bip44AddressKeyDeriver);\n\n  return bip44AddressKeyDeriver;\n}\n\n/**\n * Get a BIP-44 coin type node from a JSON node or extended key string. If an existing coin type\n * node is provided, the same node is returned.\n *\n * The depth of the node is validated to be a valid coin type node.\n *\n * @param node - A BIP-44 coin type node, JSON node or extended key.\n * @param cryptographicFunctions - The cryptographic functions to use. If\n * provided, these will be used instead of the built-in implementations. This is\n * only used if the node is an extended key string or JSON object.\n * @returns A BIP44CoinType node.\n */\nasync function getNode(\n  node: BIP44CoinTypeNode | JsonBIP44CoinTypeNode | string,\n  cryptographicFunctions?: CryptographicFunctions,\n): Promise<BIP44CoinTypeNode> {\n  if (node instanceof BIP44CoinTypeNode) {\n    validateCoinTypeNodeDepth(node.depth);\n\n    return node;\n  }\n\n  if (typeof node === 'string') {\n    const bip44Node = await BIP44Node.fromExtendedKey(\n      node,\n      cryptographicFunctions,\n    );\n    const coinTypeNode = await BIP44CoinTypeNode.fromNode(\n      bip44Node,\n      bip44Node.index - BIP_32_HARDENED_OFFSET,\n    );\n\n    validateCoinTypeNodeDepth(coinTypeNode.depth);\n\n    return coinTypeNode;\n  }\n\n  return BIP44CoinTypeNode.fromJSON(\n    node,\n    node.coin_type,\n    cryptographicFunctions,\n  );\n}\n"]}

package/dist/BIP44Node.d.ts

@@ -0,0 +1,220 @@
+import type { BIP44Depth, Network, PartialHDPathTuple, RootedSLIP10PathTuple, RootedSLIP10SeedPathTuple } from './constants.js';
+import type { CryptographicFunctions } from './cryptography.js';
+import type { SupportedCurve } from './curves/index.js';
+import { SLIP10Node } from './SLIP10Node.js';
+export type BIP44ExtendedKeyOptions = {
+    readonly depth: number;
+    readonly parentFingerprint: number;
+    readonly index: number;
+    readonly network?: Network | undefined;
+    readonly chainCode: Uint8Array | string;
+    readonly privateKey?: Uint8Array | string | undefined;
+    readonly publicKey?: Uint8Array | string | undefined;
+};
+export type BIP44DerivationPathOptions = {
+    readonly derivationPath: RootedSLIP10PathTuple;
+    readonly network?: Network | undefined;
+};
+export type BIP44SeedOptions = {
+    readonly derivationPath: RootedSLIP10SeedPathTuple;
+    readonly network?: Network | undefined;
+};
+/**
+ * A wrapper for BIP-44 Hierarchical Deterministic (HD) tree nodes, i.e.
+ * cryptographic keys used to generate keypairs and addresses for cryptocurrency
+ * protocols.
+ */
+export type JsonBIP44Node = {
+    /**
+     * The 0-indexed BIP-44 path depth of this node.
+     *
+     * A BIP-44 path is of the form:
+     *
+     * `m / 44' / coin_type' / account' / change / address_index`
+     *
+     * With the following depths:
+     *
+     * `0 / 1 / 2 / 3 / 4 / 5`
+     */
+    readonly depth: BIP44Depth;
+    /**
+     * The fingerprint of the master node, i.e., the node at depth 0. May be
+     * undefined if this node was created from an extended key.
+     */
+    readonly masterFingerprint?: number | undefined;
+    /**
+     * The fingerprint of the parent key, or 0 if this is a master node.
+     */
+    readonly parentFingerprint: number;
+    /**
+     * The index of the node, or 0 if this is a master node.
+     */
+    readonly index: number;
+    /**
+     * The network for the node. This is only used for extended keys, and defaults
+     * to `mainnet`.
+     */
+    readonly network?: Network | undefined;
+    /**
+     * The hexadecimal string representation of the private key for this node.
+     * May be `undefined` if the node is a public node.
+     */
+    readonly privateKey?: string | undefined;
+    /**
+     * The hexadecimal string representation of the public key for this node.
+     */
+    readonly publicKey: string;
+    /**
+     * The hexadecimal string representation of the chain code for this node.
+     */
+    readonly chainCode: string;
+};
+export type BIP44NodeInterface = JsonBIP44Node & {
+    /**
+     * @returns A JSON-compatible representation of this node's data fields.
+     */
+    toJSON(): JsonBIP44Node;
+};
+/**
+ * A wrapper for BIP-44 Hierarchical Deterministic (HD) tree nodes, i.e.
+ * cryptographic keys used to generate keypairs and addresses for cryptocurrency
+ * protocols.
+ *
+ * This class contains methods and fields that may not serialize well. Use
+ * {@link BIP44Node.toJSON} to get a JSON-compatible representation.
+ */
+export declare class BIP44Node implements BIP44NodeInterface {
+    #private;
+    /**
+     * Wrapper of the {@link fromExtendedKey} function. Refer to that function
+     * for documentation.
+     *
+     * @param json - The JSON representation of a SLIP-10 node.
+     * @param cryptographicFunctions - The cryptographic functions to use. If
+     * provided, these will be used instead of the built-in implementations.
+     * @returns A BIP44 node.
+     */
+    static fromJSON(json: JsonBIP44Node, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44Node>;
+    /**
+     * Create a new BIP-44 node from a key and chain code. You must specify
+     * either a private key or a public key. When specifying a private key,
+     * the public key will be derived from the private key.
+     *
+     * All parameters are stringently validated, and an error is thrown if
+     * validation fails.
+     *
+     * @param options - An object containing the extended key, or an extended
+     * public (xpub) or private (xprv) key.
+     * @param options.depth - The depth of the node.
+     * @param options.network - The network for the node. This is only used for
+     * extended keys, and defaults to `mainnet`.
+     * @param options.privateKey - The private key for the node.
+     * @param options.publicKey - The public key for the node. If a private key is
+     * specified, this parameter is ignored.
+     * @param options.chainCode - The chain code for the node.
+     * @param cryptographicFunctions - The cryptographic functions to use. If
+     * provided, these will be used instead of the built-in implementations.
+     * @returns A BIP44 node.
+     */
+    static fromExtendedKey(options: BIP44ExtendedKeyOptions | string, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44Node>;
+    /**
+     * Create a new BIP-44 node from a derivation path. The derivation path
+     * must be rooted, i.e. it must begin with a BIP-39 node, given as a string of
+     * the form `bip39:MNEMONIC`, where `MNEMONIC` is a space-separated list of
+     * BIP-39 seed phrase words.
+     *
+     * All parameters are stringently validated, and an error is thrown if
+     * validation fails.
+     *
+     * 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 options - An object containing the derivation path.
+     * @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 BIP44 node.
+     */
+    static fromDerivationPath({ derivationPath, network }: BIP44DerivationPathOptions, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44Node>;
+    /**
+     * Create a new BIP-44 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 }: BIP44SeedOptions, cryptographicFunctions?: CryptographicFunctions): Promise<BIP44Node>;
+    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 extendedKey(): string;
+    get curve(): SupportedCurve;
+    constructor(node: SLIP10Node);
+    /**
+     * Get a neutered version of this node, i.e. a node without a private key.
+     *
+     * @returns A neutered version of this node.
+     */
+    neuter(): BIP44Node;
+    /**
+     * Derives a child of the key contains be this node and returns a new
+     * {@link BIP44Node} containing the child key.
+     *
+     * The specified path must be a valid HD path from this node, per BIP-44.
+     * At present, this means that the path must consist of no more than 5 BIP-32
+     * nodes, depending on the depth of this node.
+     *
+     * 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 path - The partial (non-rooted) BIP-44 HD tree path will be used
+     * to derive a child key from the parent key contained within this node.
+     * @returns The {@link BIP44Node} corresponding to the derived child key.
+     */
+    derive(path: PartialHDPathTuple): Promise<BIP44Node>;
+    toJSON(): JsonBIP44Node;
+}
+/**
+ * Validates a BIP-44 path depth. Effectively, asserts that the depth is an
+ * integer `number` N such that 0 <= N <= 5. Throws an error if validation
+ * fails.
+ *
+ * @param depth - The depth to validate.
+ */
+export declare function validateBIP44Depth(depth: unknown): asserts depth is BIP44Depth;
+//# sourceMappingURL=BIP44Node.d.ts.map

package/dist/BIP44Node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BIP44Node.d.ts","sourceRoot":"","sources":["../src/BIP44Node.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,UAAU,EACV,OAAO,EACP,kBAAkB,EAClB,qBAAqB,EACrB,yBAAyB,EAE1B,MAAM,gBAAgB,CAAC;AAQxB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAE,UAAU,EAAsB,MAAM,iBAAiB,CAAC;AAGjE,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM,CAAC;IACxC,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,CAAC,cAAc,EAAE,qBAAqB,CAAC;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,cAAc,EAAE,yBAAyB,CAAC;IACnD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACxC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAE3B;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEhD;;OAEG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IAEnC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAEvC;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEzC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C;;OAEG;IACH,MAAM,IAAI,aAAa,CAAC;CACzB,CAAC;AAEF;;;;;;;GAOG;AACH,qBAAa,SAAU,YAAW,kBAAkB;;IAClD;;;;;;;;OAQG;IACH,OAAa,QAAQ,CACnB,IAAI,EAAE,aAAa,EACnB,sBAAsB,CAAC,EAAE,sBAAsB,GAC9C,OAAO,CAAC,SAAS,CAAC,CAEpB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAa,eAAe,CAC1B,OAAO,EAAE,uBAAuB,GAAG,MAAM,EACzC,sBAAsB,CAAC,EAAE,sBAAsB,GAC9C,OAAO,CAAC,SAAS,CAAC,CAiEpB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAa,kBAAkB,CAC7B,EAAE,cAAc,EAAE,OAAO,EAAE,EAAE,0BAA0B,EACvD,sBAAsB,CAAC,EAAE,sBAAsB,GAC9C,OAAO,CAAC,SAAS,CAAC,CAcpB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,OAAa,QAAQ,CACnB,EAAE,cAAc,EAAE,OAAO,EAAE,EAAE,gBAAgB,EAC7C,sBAAsB,CAAC,EAAE,sBAAsB,GAC9C,OAAO,CAAC,SAAS,CAAC,CAcpB;IAID,IAAW,KAAK,IAAI,UAAU,CAE7B;IAED,IAAW,eAAe,IAAI,UAAU,GAAG,SAAS,CAEnD;IAED,IAAW,cAAc,IAAI,UAAU,CAEtC;IAED,IAAW,cAAc,IAAI,UAAU,CAEtC;IAED,IAAW,UAAU,IAAI,MAAM,GAAG,SAAS,CAE1C;IAED,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,mBAAmB,IAAI,MAAM,CAEvC;IAED,IAAW,wBAAwB,IAAI,UAAU,CAEhD;IAED,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,iBAAiB,IAAI,MAAM,GAAG,SAAS,CAEjD;IAED,IAAW,iBAAiB,IAAI,MAAM,CAErC;IAED,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,KAAK,IAAI,MAAM,CAEzB;IAED,IAAW,OAAO,IAAI,OAAO,CAE5B;IAED,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,KAAK,IAAI,cAAc,CAEjC;IAED,YAAY,IAAI,EAAE,UAAU,EAI3B;IAED;;;;OAIG;IACI,MAAM,IAAI,SAAS,CAGzB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACU,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,SAAS,CAAC,CAchE;IAGM,MAAM,IAAI,aAAa,CAW7B;CACF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,UAAU,CAQ7B"}