@hiero-ledger/sdk 2.70.0

package/lib/Mnemonic.cjs

@@ -0,0 +1,232 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cryptography = require("@hashgraph/cryptography");
+var _Cache = _interopRequireDefault(require("./Cache.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @typedef {import("./PrivateKey.js").default} PrivateKey
+ */
+
+const HARDENED_BIT = 0x80000000;
+
+/**
+ * Multi-word mnemonic phrase (BIP-39).
+ *
+ * Compatible with the official Hiero mobile
+ * wallets (24-words or 22-words) and BRD (12-words).
+ */
+class Mnemonic {
+  /**
+   * @param {MnemonicCryptography} mnemonic
+   * @hideconstructor
+   * @private
+   */
+  constructor(mnemonic) {
+    this._mnemonic = mnemonic;
+  }
+
+  /**
+   * Returns a new random 24-word mnemonic from the BIP-39
+   * standard English word list.
+   *
+   * @returns {Promise<Mnemonic>}
+   */
+  static async generate() {
+    return new Mnemonic(await _cryptography.Mnemonic._generate(24));
+  }
+
+  /**
+   * Returns a new random 12-word mnemonic from the BIP-39
+   * standard English word list.
+   *
+   * @returns {Promise<Mnemonic>}
+   */
+  static async generate12() {
+    return new Mnemonic(await _cryptography.Mnemonic._generate(12));
+  }
+
+  /**
+   * Construct a mnemonic from a list of words. Handles 12, 22 (legacy), and 24 words.
+   *
+   * An exception of BadMnemonicError will be thrown if the mnemonic
+   * contains unknown words or fails the checksum. An invalid mnemonic
+   * can still be used to create private keys, the exception will
+   * contain the failing mnemonic in case you wish to ignore the
+   * validation error and continue.
+   *
+   * @param {string[]} words
+   * @throws {cryptography.BadMnemonicError}
+   * @returns {Promise<Mnemonic>}
+   */
+  static async fromWords(words) {
+    return new Mnemonic(await _cryptography.Mnemonic.fromWords(words));
+  }
+
+  /**
+   * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead
+   * Recover a private key from this mnemonic phrase, with an
+   * optional passphrase.
+   * @param {string} [passphrase]
+   * @returns {Promise<PrivateKey>}
+   */
+  async toPrivateKey(passphrase = "") {
+    return _Cache.default.privateKeyConstructor(
+    // eslint-disable-next-line deprecation/deprecation
+    await this._mnemonic.toPrivateKey(passphrase));
+  }
+
+  /**
+   * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead
+   * Recover an Ed25519 private key from this mnemonic phrase, with an
+   * optional passphrase.
+   * @param {string} [passphrase]
+   * @param {number[]} [path]
+   * @returns {Promise<PrivateKey>}
+   */
+  async toEd25519PrivateKey(passphrase = "", path) {
+    return _Cache.default.privateKeyConstructor(
+    // eslint-disable-next-line deprecation/deprecation
+    await this._mnemonic.toEd25519PrivateKey(passphrase, path));
+  }
+
+  /**
+   * Recover an Ed25519 private key from this mnemonic phrase, with an
+   * optional passphrase.
+   *
+   * @param {string} [passphrase]
+   * @param {number} [index]
+   * @returns {Promise<PrivateKey>}
+   */
+  async toStandardEd25519PrivateKey(passphrase = "", index) {
+    return _Cache.default.privateKeyConstructor(await this._mnemonic.toStandardEd25519PrivateKey(passphrase, index));
+  }
+
+  /**
+   * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead
+   * Recover an ECDSA private key from this mnemonic phrase, with an
+   * optional passphrase.
+   * @param {string} [passphrase]
+   * @param {number[]} [path]
+   * @returns {Promise<PrivateKey>}
+   */
+  async toEcdsaPrivateKey(passphrase = "", path) {
+    return _Cache.default.privateKeyConstructor(
+    // eslint-disable-next-line deprecation/deprecation
+    await this._mnemonic.toEcdsaPrivateKey(passphrase, path));
+  }
+
+  /**
+   * Converts a derivation path from string to an array of integers.
+   * Note that this expects precisely 5 components in the derivation path,
+   * as per BIP-44:
+   * `m / purpose' / coin_type' / account' / change / address_index`
+   * Takes into account `'` for hardening as per BIP-32,
+   * and does not prescribe which components should be hardened.
+   *
+   * @param {string} derivationPath    the derivation path in BIP-44 format,
+   *                                   e.g. "m/44'/60'/0'/0/0"
+   * @returns {Array<number>} to be used with PrivateKey#derive
+   */
+  calculateDerivationPathValues(derivationPath) {
+    // Parse the derivation path from string into values
+    const pattern = /m\/(\d+'?)\/(\d+'?)\/(\d+'?)\/(\d+'?)\/(\d+'?)/;
+    const matches = pattern.exec(derivationPath);
+    const values = new Array(5); // as Array<Number>;
+    if (matches) {
+      // Extract numbers and use apostrophe to select if is hardened
+      for (let i = 1; i <= 5; i++) {
+        let value = matches[i];
+        if (value.endsWith("'")) {
+          value = value.substring(0, value.length - 1);
+          values[i - 1] = parseInt(value, 10) | HARDENED_BIT;
+        } else {
+          values[i - 1] = parseInt(value, 10);
+        }
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return values;
+  }
+
+  /**
+   * Common implementation for both `toStandardECDSAsecp256k1PrivateKey`
+   * functions.
+   *
+   * @param {string} passphrase  the passphrase used to protect the
+   *                             mnemonic, use "" for none
+   * @param {Array<number>} derivationPathValues derivation path as an
+   *                             integer array,
+   *                             see: `calculateDerivationPathValues`
+   * @returns {Promise<PrivateKey>}  a private key
+   */
+  async toStandardECDSAsecp256k1PrivateKeyImpl(passphrase, derivationPathValues) {
+    // eslint-disable-next-line deprecation/deprecation
+    return await this.toEcdsaPrivateKey(passphrase, derivationPathValues);
+  }
+
+  /**
+   * Recover an ECDSA private key from this mnemonic phrase, with an
+   * optional passphrase.
+   *
+   * @param {string} [passphrase]
+   * @param {number} [index]
+   * @returns {Promise<PrivateKey>}
+   */
+  async toStandardECDSAsecp256k1PrivateKey(passphrase = "", index) {
+    return _Cache.default.privateKeyConstructor(await this._mnemonic.toStandardECDSAsecp256k1PrivateKey(passphrase, index));
+  }
+
+  /**
+   * Recover an ECDSAsecp256k1 private key from this mnemonic phrase and
+   * derivation path, with an optional passphrase
+   *
+   * @param {string} passphrase      the passphrase used to protect the mnemonic,
+   *                                 use "" for none
+   * @param {string} derivationPath  the derivation path in BIP-44 format,
+   *                                 e.g. "m/44'/60'/0'/0/0"
+   * @returns {Promise<PrivateKey>}  the private key
+   */
+  async toStandardECDSAsecp256k1PrivateKeyCustomDerivationPath(passphrase = "", derivationPath) {
+    const derivationPathValues = this.calculateDerivationPathValues(derivationPath);
+    return await this.toStandardECDSAsecp256k1PrivateKeyImpl(passphrase, derivationPathValues);
+  }
+
+  /**
+   * Recover a mnemonic phrase from a string, splitting on spaces. Handles 12, 22 (legacy), and 24 words.
+   *
+   * @param {string} mnemonic
+   * @returns {Promise<Mnemonic>}
+   */
+  static async fromString(mnemonic) {
+    return new Mnemonic(await _cryptography.Mnemonic.fromString(mnemonic));
+  }
+
+  /**
+   * @returns {Promise<PrivateKey>}
+   */
+  async toLegacyPrivateKey() {
+    return _Cache.default.privateKeyConstructor(await this._mnemonic.toLegacyPrivateKey());
+  }
+
+  /**
+   * @param {string} passphrase
+   * @returns {Promise<Uint8Array>}
+   */
+  async toSeed(passphrase) {
+    return await _cryptography.Mnemonic.toSeed(this._mnemonic.words, passphrase);
+  }
+
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return this._mnemonic.toString();
+  }
+}
+exports.default = Mnemonic;

package/lib/Mnemonic.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Multi-word mnemonic phrase (BIP-39).
+ *
+ * Compatible with the official Hiero mobile
+ * wallets (24-words or 22-words) and BRD (12-words).
+ */
+export default class Mnemonic {
+    /**
+     * Returns a new random 24-word mnemonic from the BIP-39
+     * standard English word list.
+     *
+     * @returns {Promise<Mnemonic>}
+     */
+    static generate(): Promise<Mnemonic>;
+    /**
+     * Returns a new random 12-word mnemonic from the BIP-39
+     * standard English word list.
+     *
+     * @returns {Promise<Mnemonic>}
+     */
+    static generate12(): Promise<Mnemonic>;
+    /**
+     * Construct a mnemonic from a list of words. Handles 12, 22 (legacy), and 24 words.
+     *
+     * An exception of BadMnemonicError will be thrown if the mnemonic
+     * contains unknown words or fails the checksum. An invalid mnemonic
+     * can still be used to create private keys, the exception will
+     * contain the failing mnemonic in case you wish to ignore the
+     * validation error and continue.
+     *
+     * @param {string[]} words
+     * @throws {cryptography.BadMnemonicError}
+     * @returns {Promise<Mnemonic>}
+     */
+    static fromWords(words: string[]): Promise<Mnemonic>;
+    /**
+     * Recover a mnemonic phrase from a string, splitting on spaces. Handles 12, 22 (legacy), and 24 words.
+     *
+     * @param {string} mnemonic
+     * @returns {Promise<Mnemonic>}
+     */
+    static fromString(mnemonic: string): Promise<Mnemonic>;
+    /**
+     * @param {MnemonicCryptography} mnemonic
+     * @hideconstructor
+     * @private
+     */
+    private constructor();
+    _mnemonic: MnemonicCryptography;
+    /**
+     * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead
+     * Recover a private key from this mnemonic phrase, with an
+     * optional passphrase.
+     * @param {string} [passphrase]
+     * @returns {Promise<PrivateKey>}
+     */
+    toPrivateKey(passphrase?: string): Promise<PrivateKey>;
+    /**
+     * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead
+     * Recover an Ed25519 private key from this mnemonic phrase, with an
+     * optional passphrase.
+     * @param {string} [passphrase]
+     * @param {number[]} [path]
+     * @returns {Promise<PrivateKey>}
+     */
+    toEd25519PrivateKey(passphrase?: string, path?: number[]): Promise<PrivateKey>;
+    /**
+     * Recover an Ed25519 private key from this mnemonic phrase, with an
+     * optional passphrase.
+     *
+     * @param {string} [passphrase]
+     * @param {number} [index]
+     * @returns {Promise<PrivateKey>}
+     */
+    toStandardEd25519PrivateKey(passphrase?: string, index?: number): Promise<PrivateKey>;
+    /**
+     * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead
+     * Recover an ECDSA private key from this mnemonic phrase, with an
+     * optional passphrase.
+     * @param {string} [passphrase]
+     * @param {number[]} [path]
+     * @returns {Promise<PrivateKey>}
+     */
+    toEcdsaPrivateKey(passphrase?: string, path?: number[]): Promise<PrivateKey>;
+    /**
+     * Converts a derivation path from string to an array of integers.
+     * Note that this expects precisely 5 components in the derivation path,
+     * as per BIP-44:
+     * `m / purpose' / coin_type' / account' / change / address_index`
+     * Takes into account `'` for hardening as per BIP-32,
+     * and does not prescribe which components should be hardened.
+     *
+     * @param {string} derivationPath    the derivation path in BIP-44 format,
+     *                                   e.g. "m/44'/60'/0'/0/0"
+     * @returns {Array<number>} to be used with PrivateKey#derive
+     */
+    calculateDerivationPathValues(derivationPath: string): Array<number>;
+    /**
+     * Common implementation for both `toStandardECDSAsecp256k1PrivateKey`
+     * functions.
+     *
+     * @param {string} passphrase  the passphrase used to protect the
+     *                             mnemonic, use "" for none
+     * @param {Array<number>} derivationPathValues derivation path as an
+     *                             integer array,
+     *                             see: `calculateDerivationPathValues`
+     * @returns {Promise<PrivateKey>}  a private key
+     */
+    toStandardECDSAsecp256k1PrivateKeyImpl(passphrase: string, derivationPathValues: Array<number>): Promise<PrivateKey>;
+    /**
+     * Recover an ECDSA private key from this mnemonic phrase, with an
+     * optional passphrase.
+     *
+     * @param {string} [passphrase]
+     * @param {number} [index]
+     * @returns {Promise<PrivateKey>}
+     */
+    toStandardECDSAsecp256k1PrivateKey(passphrase?: string, index?: number): Promise<PrivateKey>;
+    /**
+     * Recover an ECDSAsecp256k1 private key from this mnemonic phrase and
+     * derivation path, with an optional passphrase
+     *
+     * @param {string} passphrase      the passphrase used to protect the mnemonic,
+     *                                 use "" for none
+     * @param {string} derivationPath  the derivation path in BIP-44 format,
+     *                                 e.g. "m/44'/60'/0'/0/0"
+     * @returns {Promise<PrivateKey>}  the private key
+     */
+    toStandardECDSAsecp256k1PrivateKeyCustomDerivationPath(passphrase: string | undefined, derivationPath: string): Promise<PrivateKey>;
+    /**
+     * @returns {Promise<PrivateKey>}
+     */
+    toLegacyPrivateKey(): Promise<PrivateKey>;
+    /**
+     * @param {string} passphrase
+     * @returns {Promise<Uint8Array>}
+     */
+    toSeed(passphrase: string): Promise<Uint8Array>;
+    /**
+     * @returns {string}
+     */
+    toString(): string;
+}
+export type PrivateKey = import("./PrivateKey.js").default;
+import { Mnemonic as MnemonicCryptography } from "@hashgraph/cryptography";

package/lib/Mnemonic.js

@@ -0,0 +1,2 @@
+import{Mnemonic as t}from"@hashgraph/cryptography";import e from"./Cache.js";class a{constructor(t){this._mnemonic=t}static async generate(){return new a(await t._generate(24))}static async generate12(){return new a(await t._generate(12))}static async fromWords(e){return new a(await t.fromWords(e))}async toPrivateKey(t=""){return e.privateKeyConstructor(await this._mnemonic.toPrivateKey(t))}async toEd25519PrivateKey(t="",a){return e.privateKeyConstructor(await this._mnemonic.toEd25519PrivateKey(t,a))}async toStandardEd25519PrivateKey(t="",a){return e.privateKeyConstructor(await this._mnemonic.toStandardEd25519PrivateKey(t,a))}async toEcdsaPrivateKey(t="",a){return e.privateKeyConstructor(await this._mnemonic.toEcdsaPrivateKey(t,a))}calculateDerivationPathValues(t){const e=/m\/(\d+'?)\/(\d+'?)\/(\d+'?)\/(\d+'?)\/(\d+'?)/.exec(t),a=new Array(5);if(e)for(let t=1;t<=5;t++){let r=e[t];r.endsWith("'")?(r=r.substring(0,r.length-1),a[t-1]=2147483648|parseInt(r,10)):a[t-1]=parseInt(r,10)}return a}async toStandardECDSAsecp256k1PrivateKeyImpl(t,e){return await this.toEcdsaPrivateKey(t,e)}async toStandardECDSAsecp256k1PrivateKey(t="",a){return e.privateKeyConstructor(await this._mnemonic.toStandardECDSAsecp256k1PrivateKey(t,a))}async toStandardECDSAsecp256k1PrivateKeyCustomDerivationPath(t="",e){const a=this.calculateDerivationPathValues(e);return await this.toStandardECDSAsecp256k1PrivateKeyImpl(t,a)}static async fromString(e){return new a(await t.fromString(e))}async toLegacyPrivateKey(){return e.privateKeyConstructor(await this._mnemonic.toLegacyPrivateKey())}async toSeed(e){return await t.toSeed(this._mnemonic.words,e)}toString(){return this._mnemonic.toString()}}export{a as default};
+//# sourceMappingURL=Mnemonic.js.map

package/lib/Mnemonic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mnemonic.js","sources":["../src/Mnemonic.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport { Mnemonic as MnemonicCryptography } from \"@hashgraph/cryptography\";\nimport CACHE from \"./Cache.js\";\n\n/**\n * @typedef {import(\"./PrivateKey.js\").default} PrivateKey\n */\n\nconst HARDENED_BIT = 0x80000000;\n\n/**\n * Multi-word mnemonic phrase (BIP-39).\n *\n * Compatible with the official Hiero mobile\n * wallets (24-words or 22-words) and BRD (12-words).\n */\nexport default class Mnemonic {\n    /**\n     * @param {MnemonicCryptography} mnemonic\n     * @hideconstructor\n     * @private\n     */\n    constructor(mnemonic) {\n        this._mnemonic = mnemonic;\n    }\n\n    /**\n     * Returns a new random 24-word mnemonic from the BIP-39\n     * standard English word list.\n     *\n     * @returns {Promise<Mnemonic>}\n     */\n    static async generate() {\n        return new Mnemonic(await MnemonicCryptography._generate(24));\n    }\n\n    /**\n     * Returns a new random 12-word mnemonic from the BIP-39\n     * standard English word list.\n     *\n     * @returns {Promise<Mnemonic>}\n     */\n    static async generate12() {\n        return new Mnemonic(await MnemonicCryptography._generate(12));\n    }\n\n    /**\n     * Construct a mnemonic from a list of words. Handles 12, 22 (legacy), and 24 words.\n     *\n     * An exception of BadMnemonicError will be thrown if the mnemonic\n     * contains unknown words or fails the checksum. An invalid mnemonic\n     * can still be used to create private keys, the exception will\n     * contain the failing mnemonic in case you wish to ignore the\n     * validation error and continue.\n     *\n     * @param {string[]} words\n     * @throws {cryptography.BadMnemonicError}\n     * @returns {Promise<Mnemonic>}\n     */\n    static async fromWords(words) {\n        return new Mnemonic(await MnemonicCryptography.fromWords(words));\n    }\n\n    /**\n     * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead\n     * Recover a private key from this mnemonic phrase, with an\n     * optional passphrase.\n     * @param {string} [passphrase]\n     * @returns {Promise<PrivateKey>}\n     */\n    async toPrivateKey(passphrase = \"\") {\n        return CACHE.privateKeyConstructor(\n            // eslint-disable-next-line deprecation/deprecation\n            await this._mnemonic.toPrivateKey(passphrase),\n        );\n    }\n\n    /**\n     * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead\n     * Recover an Ed25519 private key from this mnemonic phrase, with an\n     * optional passphrase.\n     * @param {string} [passphrase]\n     * @param {number[]} [path]\n     * @returns {Promise<PrivateKey>}\n     */\n    async toEd25519PrivateKey(passphrase = \"\", path) {\n        return CACHE.privateKeyConstructor(\n            // eslint-disable-next-line deprecation/deprecation\n            await this._mnemonic.toEd25519PrivateKey(passphrase, path),\n        );\n    }\n\n    /**\n     * Recover an Ed25519 private key from this mnemonic phrase, with an\n     * optional passphrase.\n     *\n     * @param {string} [passphrase]\n     * @param {number} [index]\n     * @returns {Promise<PrivateKey>}\n     */\n    async toStandardEd25519PrivateKey(passphrase = \"\", index) {\n        return CACHE.privateKeyConstructor(\n            await this._mnemonic.toStandardEd25519PrivateKey(passphrase, index),\n        );\n    }\n\n    /**\n     * @deprecated - Use `toStandardEd25519PrivateKey()` or `toStandardECDSAsecp256k1PrivateKey()` instead\n     * Recover an ECDSA private key from this mnemonic phrase, with an\n     * optional passphrase.\n     * @param {string} [passphrase]\n     * @param {number[]} [path]\n     * @returns {Promise<PrivateKey>}\n     */\n    async toEcdsaPrivateKey(passphrase = \"\", path) {\n        return CACHE.privateKeyConstructor(\n            // eslint-disable-next-line deprecation/deprecation\n            await this._mnemonic.toEcdsaPrivateKey(passphrase, path),\n        );\n    }\n\n    /**\n     * Converts a derivation path from string to an array of integers.\n     * Note that this expects precisely 5 components in the derivation path,\n     * as per BIP-44:\n     * `m / purpose' / coin_type' / account' / change / address_index`\n     * Takes into account `'` for hardening as per BIP-32,\n     * and does not prescribe which components should be hardened.\n     *\n     * @param {string} derivationPath    the derivation path in BIP-44 format,\n     *                                   e.g. \"m/44'/60'/0'/0/0\"\n     * @returns {Array<number>} to be used with PrivateKey#derive\n     */\n    calculateDerivationPathValues(derivationPath) {\n        // Parse the derivation path from string into values\n        const pattern = /m\\/(\\d+'?)\\/(\\d+'?)\\/(\\d+'?)\\/(\\d+'?)\\/(\\d+'?)/;\n        const matches = pattern.exec(derivationPath);\n        const values = new Array(5); // as Array<Number>;\n        if (matches) {\n            // Extract numbers and use apostrophe to select if is hardened\n            for (let i = 1; i <= 5; i++) {\n                let value = matches[i];\n                if (value.endsWith(\"'\")) {\n                    value = value.substring(0, value.length - 1);\n                    values[i - 1] = parseInt(value, 10) | HARDENED_BIT;\n                } else {\n                    values[i - 1] = parseInt(value, 10);\n                }\n            }\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return values;\n    }\n\n    /**\n     * Common implementation for both `toStandardECDSAsecp256k1PrivateKey`\n     * functions.\n     *\n     * @param {string} passphrase  the passphrase used to protect the\n     *                             mnemonic, use \"\" for none\n     * @param {Array<number>} derivationPathValues derivation path as an\n     *                             integer array,\n     *                             see: `calculateDerivationPathValues`\n     * @returns {Promise<PrivateKey>}  a private key\n     */\n    async toStandardECDSAsecp256k1PrivateKeyImpl(\n        passphrase,\n        derivationPathValues,\n    ) {\n        // eslint-disable-next-line deprecation/deprecation\n        return await this.toEcdsaPrivateKey(passphrase, derivationPathValues);\n    }\n\n    /**\n     * Recover an ECDSA private key from this mnemonic phrase, with an\n     * optional passphrase.\n     *\n     * @param {string} [passphrase]\n     * @param {number} [index]\n     * @returns {Promise<PrivateKey>}\n     */\n    async toStandardECDSAsecp256k1PrivateKey(passphrase = \"\", index) {\n        return CACHE.privateKeyConstructor(\n            await this._mnemonic.toStandardECDSAsecp256k1PrivateKey(\n                passphrase,\n                index,\n            ),\n        );\n    }\n\n    /**\n     * Recover an ECDSAsecp256k1 private key from this mnemonic phrase and\n     * derivation path, with an optional passphrase\n     *\n     * @param {string} passphrase      the passphrase used to protect the mnemonic,\n     *                                 use \"\" for none\n     * @param {string} derivationPath  the derivation path in BIP-44 format,\n     *                                 e.g. \"m/44'/60'/0'/0/0\"\n     * @returns {Promise<PrivateKey>}  the private key\n     */\n    async toStandardECDSAsecp256k1PrivateKeyCustomDerivationPath(\n        passphrase = \"\",\n        derivationPath,\n    ) {\n        const derivationPathValues =\n            this.calculateDerivationPathValues(derivationPath);\n        return await this.toStandardECDSAsecp256k1PrivateKeyImpl(\n            passphrase,\n            derivationPathValues,\n        );\n    }\n\n    /**\n     * Recover a mnemonic phrase from a string, splitting on spaces. Handles 12, 22 (legacy), and 24 words.\n     *\n     * @param {string} mnemonic\n     * @returns {Promise<Mnemonic>}\n     */\n    static async fromString(mnemonic) {\n        return new Mnemonic(await MnemonicCryptography.fromString(mnemonic));\n    }\n\n    /**\n     * @returns {Promise<PrivateKey>}\n     */\n    async toLegacyPrivateKey() {\n        return CACHE.privateKeyConstructor(\n            await this._mnemonic.toLegacyPrivateKey(),\n        );\n    }\n\n    /**\n     * @param {string} passphrase\n     * @returns {Promise<Uint8Array>}\n     */\n    async toSeed(passphrase) {\n        return await MnemonicCryptography.toSeed(\n            this._mnemonic.words,\n            passphrase,\n        );\n    }\n\n    /**\n     * @returns {string}\n     */\n    toString() {\n        return this._mnemonic.toString();\n    }\n}\n"],"names":["Mnemonic","constructor","mnemonic","this","_mnemonic","generate","MnemonicCryptography","_generate","generate12","fromWords","words","toPrivateKey","passphrase","CACHE","privateKeyConstructor","toEd25519PrivateKey","path","toStandardEd25519PrivateKey","index","toEcdsaPrivateKey","calculateDerivationPathValues","derivationPath","matches","exec","values","Array","i","value","endsWith","substring","length","parseInt","toStandardECDSAsecp256k1PrivateKeyImpl","derivationPathValues","toStandardECDSAsecp256k1PrivateKey","toStandardECDSAsecp256k1PrivateKeyCustomDerivationPath","fromString","toLegacyPrivateKey","toSeed","toString"],"mappings":"6EAiBe,MAAMA,EAMjB,WAAAC,CAAYC,GACRC,KAAKC,UAAYF,CACzB,CAQI,qBAAaG,GACT,OAAO,IAAIL,QAAeM,EAAqBC,UAAU,IACjE,CAQI,uBAAaC,GACT,OAAO,IAAIR,QAAeM,EAAqBC,UAAU,IACjE,CAeI,sBAAaE,CAAUC,GACnB,OAAO,IAAIV,QAAeM,EAAqBG,UAAUC,GACjE,CASI,kBAAMC,CAAaC,EAAa,IAC5B,OAAOC,EAAMC,4BAEHX,KAAKC,UAAUO,aAAaC,GAE9C,CAUI,yBAAMG,CAAoBH,EAAa,GAAII,GACvC,OAAOH,EAAMC,4BAEHX,KAAKC,UAAUW,oBAAoBH,EAAYI,GAEjE,CAUI,iCAAMC,CAA4BL,EAAa,GAAIM,GAC/C,OAAOL,EAAMC,4BACHX,KAAKC,UAAUa,4BAA4BL,EAAYM,GAEzE,CAUI,uBAAMC,CAAkBP,EAAa,GAAII,GACrC,OAAOH,EAAMC,4BAEHX,KAAKC,UAAUe,kBAAkBP,EAAYI,GAE/D,CAcI,6BAAAI,CAA8BC,GAE1B,MACMC,EADU,iDACQC,KAAKF,GACvBG,EAAS,IAAIC,MAAM,GACzB,GAAIH,EAEA,IAAK,IAAII,EAAI,EAAGA,GAAK,EAAGA,IAAK,CACzB,IAAIC,EAAQL,EAAQI,GAChBC,EAAMC,SAAS,MACfD,EAAQA,EAAME,UAAU,EAAGF,EAAMG,OAAS,GAC1CN,EAAOE,EAAI,GAxIV,WAwIeK,SAASJ,EAAO,KAEhCH,EAAOE,EAAI,GAAKK,SAASJ,EAAO,GAEpD,CAGQ,OAAOH,CACf,CAaI,4CAAMQ,CACFpB,EACAqB,GAGA,aAAa9B,KAAKgB,kBAAkBP,EAAYqB,EACxD,CAUI,wCAAMC,CAAmCtB,EAAa,GAAIM,GACtD,OAAOL,EAAMC,4BACHX,KAAKC,UAAU8B,mCACjBtB,EACAM,GAGhB,CAYI,4DAAMiB,CACFvB,EAAa,GACbS,GAEA,MAAMY,EACF9B,KAAKiB,8BAA8BC,GACvC,aAAalB,KAAK6B,uCACdpB,EACAqB,EAEZ,CAQI,uBAAaG,CAAWlC,GACpB,OAAO,IAAIF,QAAeM,EAAqB8B,WAAWlC,GAClE,CAKI,wBAAMmC,GACF,OAAOxB,EAAMC,4BACHX,KAAKC,UAAUiC,qBAEjC,CAMI,YAAMC,CAAO1B,GACT,aAAaN,EAAqBgC,OAC9BnC,KAAKC,UAAUM,MACfE,EAEZ,CAKI,QAAA2B,GACI,OAAOpC,KAAKC,UAAUmC,UAC9B"}

package/lib/Node.cjs

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ManagedNode = _interopRequireDefault(require("./ManagedNode.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ * @typedef {import("./address_book/NodeAddress.js").default} NodeAddress
+ * @typedef {import("./channel/Channel.js").default} Channel
+ * @typedef {import("./ManagedNodeAddress.js").default} ManagedNodeAddress
+ * @typedef {import("./LedgerId.js").default} LedgerId
+ */
+
+/**
+ * @typedef {object} NewNode
+ * @property {AccountId} accountId
+ * @property {string} address
+ * @property {(address: string) => Channel} channelInitFunction
+ */
+
+/**
+ * @typedef {object} CloneNode
+ * @property {Node} node
+ * @property {ManagedNodeAddress} address
+ */
+
+/**
+ * @augments {ManagedNode<Channel>}
+ */
+class Node extends _ManagedNode.default {
+  /**
+   * @param {object} props
+   * @param {NewNode=} [props.newNode]
+   * @param {CloneNode=} [props.cloneNode]
+   */
+  constructor(props = {}) {
+    super(props);
+    if (props.newNode != null) {
+      /** @type {AccountId} */
+      this._accountId = props.newNode.accountId;
+
+      /** @type {NodeAddress | null} */
+      this._nodeAddress = null;
+    } else if (props.cloneNode != null) {
+      /** @type {AccountId} */
+      this._accountId = props.cloneNode.node._accountId;
+
+      /** @type {NodeAddress | null} */
+      this._nodeAddress = props.cloneNode.node._nodeAddress;
+    } else {
+      throw new Error(`failed to create node: ${JSON.stringify(props)}`);
+    }
+  }
+
+  /**
+   * @returns {string}
+   */
+  getKey() {
+    return this._accountId.toString();
+  }
+
+  /**
+   * @returns {ManagedNode<Channel>}
+   */
+  toInsecure() {
+    return /** @type {this} */new Node({
+      cloneNode: {
+        node: this,
+        address: this._address.toInsecure()
+      }
+    });
+  }
+
+  /**
+   * @returns {ManagedNode<Channel>}
+   */
+  toSecure() {
+    return /** @type {this} */new Node({
+      cloneNode: {
+        node: this,
+        address: this._address.toSecure()
+      }
+    });
+  }
+
+  /**
+   * @returns {AccountId}
+   */
+  get accountId() {
+    return this._accountId;
+  }
+
+  /**
+   * @returns {NodeAddress | null}
+   */
+  get nodeAddress() {
+    return this._nodeAddress;
+  }
+
+  /**
+   * @param {NodeAddress} nodeAddress
+   * @returns {this}
+   */
+  setNodeAddress(nodeAddress) {
+    this._nodeAddress = nodeAddress;
+    return this;
+  }
+}
+exports.default = Node;

package/lib/Node.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @typedef {import("./account/AccountId.js").default} AccountId
+ * @typedef {import("./address_book/NodeAddress.js").default} NodeAddress
+ * @typedef {import("./channel/Channel.js").default} Channel
+ * @typedef {import("./ManagedNodeAddress.js").default} ManagedNodeAddress
+ * @typedef {import("./LedgerId.js").default} LedgerId
+ */
+/**
+ * @typedef {object} NewNode
+ * @property {AccountId} accountId
+ * @property {string} address
+ * @property {(address: string) => Channel} channelInitFunction
+ */
+/**
+ * @typedef {object} CloneNode
+ * @property {Node} node
+ * @property {ManagedNodeAddress} address
+ */
+/**
+ * @augments {ManagedNode<Channel>}
+ */
+export default class Node extends ManagedNode<import("./channel/Channel.js").default> {
+    /**
+     * @param {object} props
+     * @param {NewNode=} [props.newNode]
+     * @param {CloneNode=} [props.cloneNode]
+     */
+    constructor(props?: {
+        newNode?: NewNode | undefined;
+        cloneNode?: CloneNode | undefined;
+    });
+    /** @type {AccountId} */
+    _accountId: AccountId;
+    /** @type {NodeAddress | null} */
+    _nodeAddress: NodeAddress | null;
+    /**
+     * @returns {ManagedNode<Channel>}
+     */
+    toInsecure(): ManagedNode<Channel>;
+    /**
+     * @returns {ManagedNode<Channel>}
+     */
+    toSecure(): ManagedNode<Channel>;
+    /**
+     * @returns {AccountId}
+     */
+    get accountId(): AccountId;
+    /**
+     * @returns {NodeAddress | null}
+     */
+    get nodeAddress(): NodeAddress | null;
+    /**
+     * @param {NodeAddress} nodeAddress
+     * @returns {this}
+     */
+    setNodeAddress(nodeAddress: NodeAddress): this;
+}
+export type AccountId = import("./account/AccountId.js").default;
+export type NodeAddress = import("./address_book/NodeAddress.js").default;
+export type Channel = import("./channel/Channel.js").default;
+export type ManagedNodeAddress = import("./ManagedNodeAddress.js").default;
+export type LedgerId = import("./LedgerId.js").default;
+export type NewNode = {
+    accountId: AccountId;
+    address: string;
+    channelInitFunction: (address: string) => Channel;
+};
+export type CloneNode = {
+    node: Node;
+    address: ManagedNodeAddress;
+};
+import ManagedNode from "./ManagedNode.js";

package/lib/Node.js

@@ -0,0 +1,2 @@
+import e from"./ManagedNode.js";class d extends e{constructor(e={}){if(super(e),null!=e.newNode)this._accountId=e.newNode.accountId,this._nodeAddress=null;else{if(null==e.cloneNode)throw new Error(`failed to create node: ${JSON.stringify(e)}`);this._accountId=e.cloneNode.node._accountId,this._nodeAddress=e.cloneNode.node._nodeAddress}}getKey(){return this._accountId.toString()}toInsecure(){return new d({cloneNode:{node:this,address:this._address.toInsecure()}})}toSecure(){return new d({cloneNode:{node:this,address:this._address.toSecure()}})}get accountId(){return this._accountId}get nodeAddress(){return this._nodeAddress}setNodeAddress(e){return this._nodeAddress=e,this}}export{d as default};
+//# sourceMappingURL=Node.js.map

package/lib/Node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Node.js","sources":["../src/Node.js"],"sourcesContent":["// SPDX-License-Identifier: Apache-2.0\n\nimport ManagedNode from \"./ManagedNode.js\";\n\n/**\n * @typedef {import(\"./account/AccountId.js\").default} AccountId\n * @typedef {import(\"./address_book/NodeAddress.js\").default} NodeAddress\n * @typedef {import(\"./channel/Channel.js\").default} Channel\n * @typedef {import(\"./ManagedNodeAddress.js\").default} ManagedNodeAddress\n * @typedef {import(\"./LedgerId.js\").default} LedgerId\n */\n\n/**\n * @typedef {object} NewNode\n * @property {AccountId} accountId\n * @property {string} address\n * @property {(address: string) => Channel} channelInitFunction\n */\n\n/**\n * @typedef {object} CloneNode\n * @property {Node} node\n * @property {ManagedNodeAddress} address\n */\n\n/**\n * @augments {ManagedNode<Channel>}\n */\nexport default class Node extends ManagedNode {\n    /**\n     * @param {object} props\n     * @param {NewNode=} [props.newNode]\n     * @param {CloneNode=} [props.cloneNode]\n     */\n    constructor(props = {}) {\n        super(props);\n\n        if (props.newNode != null) {\n            /** @type {AccountId} */\n            this._accountId = props.newNode.accountId;\n\n            /** @type {NodeAddress | null} */\n            this._nodeAddress = null;\n        } else if (props.cloneNode != null) {\n            /** @type {AccountId} */\n            this._accountId = props.cloneNode.node._accountId;\n\n            /** @type {NodeAddress | null} */\n            this._nodeAddress = props.cloneNode.node._nodeAddress;\n        } else {\n            throw new Error(`failed to create node: ${JSON.stringify(props)}`);\n        }\n    }\n\n    /**\n     * @returns {string}\n     */\n    getKey() {\n        return this._accountId.toString();\n    }\n\n    /**\n     * @returns {ManagedNode<Channel>}\n     */\n    toInsecure() {\n        return /** @type {this} */ (\n            new Node({\n                cloneNode: { node: this, address: this._address.toInsecure() },\n            })\n        );\n    }\n\n    /**\n     * @returns {ManagedNode<Channel>}\n     */\n    toSecure() {\n        return /** @type {this} */ (\n            new Node({\n                cloneNode: { node: this, address: this._address.toSecure() },\n            })\n        );\n    }\n\n    /**\n     * @returns {AccountId}\n     */\n    get accountId() {\n        return this._accountId;\n    }\n\n    /**\n     * @returns {NodeAddress | null}\n     */\n    get nodeAddress() {\n        return this._nodeAddress;\n    }\n\n    /**\n     * @param {NodeAddress} nodeAddress\n     * @returns {this}\n     */\n    setNodeAddress(nodeAddress) {\n        this._nodeAddress = nodeAddress;\n        return this;\n    }\n}\n"],"names":["Node","ManagedNode","constructor","props","super","newNode","this","_accountId","accountId","_nodeAddress","cloneNode","Error","JSON","stringify","node","getKey","toString","toInsecure","address","_address","toSecure","nodeAddress","setNodeAddress"],"mappings":"gCA4Be,MAAMA,UAAaC,EAM9B,WAAAC,CAAYC,EAAQ,IAGhB,GAFAC,MAAMD,GAEe,MAAjBA,EAAME,QAENC,KAAKC,WAAaJ,EAAME,QAAQG,UAGhCF,KAAKG,aAAe,SACjB,IAAuB,MAAnBN,EAAMO,UAOb,MAAM,IAAIC,MAAM,0BAA0BC,KAAKC,UAAUV,MALzDG,KAAKC,WAAaJ,EAAMO,UAAUI,KAAKP,WAGvCD,KAAKG,aAAeN,EAAMO,UAAUI,KAAKL,YAGrD,CACA,CAKI,MAAAM,GACI,OAAOT,KAAKC,WAAWS,UAC/B,CAKI,UAAAC,GACI,OAAA,IACQjB,EAAK,CACLU,UAAW,CAAEI,KAAMR,KAAMY,QAASZ,KAAKa,SAASF,eAGhE,CAKI,QAAAG,GACI,OAAA,IACQpB,EAAK,CACLU,UAAW,CAAEI,KAAMR,KAAMY,QAASZ,KAAKa,SAASC,aAGhE,CAKI,aAAIZ,GACA,OAAOF,KAAKC,UACpB,CAKI,eAAIc,GACA,OAAOf,KAAKG,YACpB,CAMI,cAAAa,CAAeD,GAEX,OADAf,KAAKG,aAAeY,EACbf,IACf"}