@neuraiproject/neurai-key 3.0.2 → 4.0.0

package/dist/index.d.ts

@@ -7,9 +7,12 @@ interface IAddressObject {
     privateKey: string;
     WIF: string;
 }
-interface PQAddressOptions {
+type AuthType = 0x00 | 0x01 | 0x02;
+interface AuthScriptOptions {
+    authType?: AuthType;
     witnessScript?: Uint8Array | string;
 }
+type PQAddressOptions = AuthScriptOptions;
 interface IPQAddressObject {
     address: string;
     mnemonic?: string;
@@ -17,7 +20,24 @@ interface IPQAddressObject {
     publicKey: string;
     privateKey: string;
     seedKey: string;
-    authType: number;
+    authType: 0x01;
+    authDescriptor: string;
+    commitment: string;
+    witnessScript: string;
+}
+interface INoAuthAddressObject {
+    address: string;
+    authType: 0x00;
+    commitment: string;
+    witnessScript: string;
+}
+interface ILegacyAuthScriptAddressObject {
+    address: string;
+    path?: string;
+    publicKey: string;
+    privateKey: string;
+    WIF: string;
+    authType: 0x02;
     authDescriptor: string;
     commitment: string;
     witnessScript: string;
@@ -47,6 +67,29 @@ declare class HDKey {
     deriveChild(index: number): HDKey;
 }
 
+declare const BIP32_PQ_EXTKEY_SIZE = 74;
+declare class PQHDKey {
+    readonly depth: number;
+    readonly index: number;
+    readonly parentFingerprint: Uint8Array;
+    readonly chainCode: Uint8Array;
+    readonly pqSeed: Uint8Array;
+    private _publicKey?;
+    private _secretKey?;
+    constructor(depth: number, index: number, parentFingerprint: Uint8Array, chainCode: Uint8Array, pqSeed: Uint8Array);
+    static fromMasterSeed(seed: Uint8Array): PQHDKey;
+    private ensureKeypair;
+    get publicKey(): Uint8Array;
+    get secretKey(): Uint8Array;
+    get fingerprint(): Uint8Array;
+    deriveChild(index: number): PQHDKey;
+    encode(): Uint8Array;
+    encodeBase58Check(version: number): string;
+    static decode(raw: Uint8Array, parentFingerprint?: Uint8Array): PQHDKey;
+    static decodeBase58Check(extKey: string, expectedVersion: number): PQHDKey;
+    derive(path: string): PQHDKey;
+}
+
 declare function getCoinType(network: Network): number;
 declare function getAddressPair(network: Network, mnemonic: string, account: number, position: number, passphrase?: string): {
     internal: IAddressObject;
@@ -67,8 +110,13 @@ declare function entropyToMnemonic(entropy: Uint8Array | string): string;
 declare function generateAddressObject(network?: Network, passphrase?: string): IAddressObject;
 declare function publicKeyToAddress(network: Network, publicKey: Uint8Array | string): string;
 declare function generateAddress(network?: Network): IAddressObject;
-declare function getPQHDKey(network: PQNetwork, mnemonic: string, passphrase?: string): HDKey;
-declare function getPQAddressByPath(network: PQNetwork, hdKey: HDKey, path: string, options?: PQAddressOptions): IPQAddressObject;
+declare function getPQHDKey(_network: PQNetwork, mnemonic: string, passphrase?: string): PQHDKey;
+declare function pqExtendedPrivateKey(network: PQNetwork, hdKey: PQHDKey): string;
+declare function pqHDKeyFromExtended(network: PQNetwork, extKey: string): PQHDKey;
+declare function getPQAddressByPath(network: PQNetwork, hdKey: PQHDKey, path: string, options?: PQAddressOptions): IPQAddressObject;
+declare function getNoAuthAddress(network: PQNetwork, options?: AuthScriptOptions): INoAuthAddressObject;
+declare function getLegacyAuthScriptAddress(network: PQNetwork, legacyNetwork: Network, mnemonic: string, account: number, index: number, passphrase?: string, options?: AuthScriptOptions): ILegacyAuthScriptAddressObject;
+declare function getLegacyAuthScriptAddressByWIF(network: PQNetwork, wif: string, options?: AuthScriptOptions): ILegacyAuthScriptAddressObject;
 declare function getPQAddress(network: PQNetwork, mnemonic: string, account: number, index: number, passphrase?: string, options?: PQAddressOptions): IPQAddressObject;
 declare function pqPublicKeyToAddress(network: PQNetwork, publicKey: Uint8Array | string, options?: PQAddressOptions): string;
 declare function pqPublicKeyToCommitmentHex(publicKey: Uint8Array | string, options?: PQAddressOptions): string;
@@ -90,11 +138,16 @@ declare const NeuraiKey: {
     getPQAddress: typeof getPQAddress;
     getPQAddressByPath: typeof getPQAddressByPath;
     getPQHDKey: typeof getPQHDKey;
+    pqExtendedPrivateKey: typeof pqExtendedPrivateKey;
+    pqHDKeyFromExtended: typeof pqHDKeyFromExtended;
+    getNoAuthAddress: typeof getNoAuthAddress;
+    getLegacyAuthScriptAddress: typeof getLegacyAuthScriptAddress;
+    getLegacyAuthScriptAddressByWIF: typeof getLegacyAuthScriptAddressByWIF;
     pqPublicKeyToAddress: typeof pqPublicKeyToAddress;
     pqPublicKeyToAuthDescriptorHex: typeof pqPublicKeyToAuthDescriptorHex;
     pqPublicKeyToCommitmentHex: typeof pqPublicKeyToCommitmentHex;
     generatePQAddressObject: typeof generatePQAddressObject;
 };
 
-export { NeuraiKey as default, entropyToMnemonic, generateAddress, generateAddressObject, generateMnemonic, generatePQAddressObject, getAddressByPath, getAddressByWIF, getAddressPair, getCoinType, getHDKey, getPQAddress, getPQAddressByPath, getPQHDKey, getPubkeyByWIF, isMnemonicValid, pqPublicKeyToAddress, pqPublicKeyToAuthDescriptorHex, pqPublicKeyToCommitmentHex, publicKeyToAddress };
-export type { IAddressObject, IPQAddressObject, Network, PQAddressOptions, PQNetwork };
+export { BIP32_PQ_EXTKEY_SIZE, HDKey, PQHDKey, NeuraiKey as default, entropyToMnemonic, generateAddress, generateAddressObject, generateMnemonic, generatePQAddressObject, getAddressByPath, getAddressByWIF, getAddressPair, getCoinType, getHDKey, getLegacyAuthScriptAddress, getLegacyAuthScriptAddressByWIF, getNoAuthAddress, getPQAddress, getPQAddressByPath, getPQHDKey, getPubkeyByWIF, isMnemonicValid, pqExtendedPrivateKey, pqHDKeyFromExtended, pqPublicKeyToAddress, pqPublicKeyToAuthDescriptorHex, pqPublicKeyToCommitmentHex, publicKeyToAddress };
+export type { AuthScriptOptions, IAddressObject, ILegacyAuthScriptAddressObject, INoAuthAddressObject, IPQAddressObject, Network, PQAddressOptions, PQNetwork };

package/dist/index.js

@@ -8,17 +8,25 @@ import { wordlist as wordlist$6 } from '@scure/bip39/wordlists/korean.js';
 import { wordlist as wordlist$7 } from '@scure/bip39/wordlists/portuguese.js';
 import { wordlist as wordlist$2 } from '@scure/bip39/wordlists/spanish.js';
 import { wordlist as wordlist$8 } from '@scure/bip39/wordlists/simplified-chinese.js';
-import { ml_dsa44 } from '@noble/post-quantum/ml-dsa.js';
 import { ripemd160 } from '@noble/hashes/legacy.js';
 import { hmac } from '@noble/hashes/hmac.js';
-import { sha256, sha512 } from '@noble/hashes/sha2.js';
-import { utf8ToBytes, bytesToHex as bytesToHex$1, hexToBytes as hexToBytes$1, concatBytes as concatBytes$1 } from '@noble/hashes/utils.js';
+import { sha512, sha256 } from '@noble/hashes/sha2.js';
+import { utf8ToBytes, concatBytes as concatBytes$1, bytesToHex as bytesToHex$1, hexToBytes as hexToBytes$1 } from '@noble/hashes/utils.js';
 import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { bech32m } from 'bech32';
+import { ml_dsa44 } from '@noble/post-quantum/ml-dsa.js';
 
 /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 function isBytes(a) {
-    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+    // Plain `instanceof Uint8Array` is too strict for some Buffer / proxy / cross-realm cases. The
+    // fallback still requires a real ArrayBuffer view, so plain JSON-deserialized
+    // `{ constructor: ... }` spoofing is rejected. `BYTES_PER_ELEMENT === 1` keeps the
+    // fallback on byte-oriented views.
+    return (a instanceof Uint8Array ||
+        (ArrayBuffer.isView(a) &&
+            a.constructor.name === 'Uint8Array' &&
+            'BYTES_PER_ELEMENT' in a &&
+            a.BYTES_PER_ELEMENT === 1));
 }
 function isArrayOf(isString, arr) {
     if (!Array.isArray(arr))
@@ -34,24 +42,26 @@ function isArrayOf(isString, arr) {
 }
 function astr(label, input) {
     if (typeof input !== 'string')
-        throw new Error(`${label}: string expected`);
+        throw new TypeError(`${label}: string expected`);
     return true;
 }
 function anumber(n) {
+    if (typeof n !== 'number')
+        throw new TypeError(`number expected, got ${typeof n}`);
     if (!Number.isSafeInteger(n))
-        throw new Error(`invalid integer: ${n}`);
+        throw new RangeError(`invalid integer: ${n}`);
 }
 function aArr(input) {
     if (!Array.isArray(input))
-        throw new Error('array expected');
+        throw new TypeError('array expected');
 }
 function astrArr(label, input) {
     if (!isArrayOf(true, input))
-        throw new Error(`${label}: array of strings expected`);
+        throw new TypeError(`${label}: array of strings expected`);
 }
 function anumArr(label, input) {
     if (!isArrayOf(false, input))
-        throw new Error(`${label}: array of numbers expected`);
+        throw new TypeError(`${label}: array of numbers expected`);
 }
 /**
  * @__NO_SIDE_EFFECTS__
@@ -104,6 +114,8 @@ function alphabet(letters) {
  */
 function join(separator = '') {
     astr('join', separator);
+    // join('') is only lossless when each chunk is already unambiguous, such as single-symbol alphabets.
+    // Multi-character tokens need a separator that cannot appear inside the chunks.
     return {
         encode: (from) => {
             astrArr('join.decode', from);
@@ -121,9 +133,9 @@ function join(separator = '') {
 function convertRadix(data, from, to) {
     // base 1 is impossible
     if (from < 2)
-        throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+        throw new RangeError(`convertRadix: invalid from=${from}, base cannot be less than 2`);
     if (to < 2)
-        throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+        throw new RangeError(`convertRadix: invalid to=${to}, base cannot be less than 2`);
     aArr(data);
     if (!data.length)
         return [];
@@ -165,6 +177,7 @@ function convertRadix(data, from, to) {
         if (done)
             break;
     }
+    // Preserve explicit leading zero digits so callers like base58 keep zero-prefix semantics.
     for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
         res.push(0);
     return res.reverse();
@@ -175,10 +188,11 @@ function convertRadix(data, from, to) {
 function radix(num) {
     anumber(num);
     const _256 = 2 ** 8;
+    // Base-range and carry-overflow checks live in convertRadix so encode/decode reject unsupported bases symmetrically.
     return {
         encode: (bytes) => {
             if (!isBytes(bytes))
-                throw new Error('radix.encode input should be Uint8Array');
+                throw new TypeError('radix.encode input should be Uint8Array');
             return convertRadix(Array.from(bytes), _256, num);
         },
         decode: (digits) => {
@@ -195,11 +209,12 @@ const genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => chain(radix(58), alphabet(
  * Quadratic (O(n^2)) - so, can't be used on large inputs.
  * @example
  * ```js
- * base58.decode('01abcdef');
- * // => '3UhJW'
+ * const text = base58.encode(Uint8Array.from([0, 1, 2]));
+ * base58.decode(text);
+ * // => Uint8Array.from([0, 1, 2])
  * ```
  */
-const base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+const base58 = /* @__PURE__ */ Object.freeze(genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'));
 
 const HARDENED_OFFSET = 0x80000000;
 const SECP256K1_ORDER = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
@@ -290,7 +305,10 @@ const BITCOIN_SEED_KEY = utf8ToBytes("Bitcoin seed");
 
 const AUTHSCRIPT_TAG = "NeuraiAuthScript";
 const AUTHSCRIPT_VERSION = 0x01;
+const NOAUTH_TYPE = 0x00;
 const PQ_AUTH_TYPE = 0x01;
+const LEGACY_AUTH_TYPE = 0x02;
+const PQ_PUBLIC_KEY_HEADER$1 = Uint8Array.from([0x05]);
 const DEFAULT_WITNESS_SCRIPT = Uint8Array.from([0x51]);
 function encodeWIF(privateKey, version, compressed = true) {
     const payload = compressed
@@ -351,27 +369,51 @@ function bech32mEncode(hrp, witnessVersion, hash) {
 function normalizeWitnessScript(input) {
     return input ? ensureBytes(input) : Uint8Array.from(DEFAULT_WITNESS_SCRIPT);
 }
+function buildAuthDescriptor(authType, publicKey) {
+    if (authType === NOAUTH_TYPE) {
+        return Uint8Array.from([NOAUTH_TYPE]);
+    }
+    if (!publicKey) {
+        throw new Error(`Auth type 0x${authType.toString(16).padStart(2, "0")} requires a public key`);
+    }
+    if (authType === PQ_AUTH_TYPE) {
+        return concatBytes(Uint8Array.from([PQ_AUTH_TYPE]), hash160(concatBytes(PQ_PUBLIC_KEY_HEADER$1, publicKey)));
+    }
+    if (authType === LEGACY_AUTH_TYPE) {
+        return concatBytes(Uint8Array.from([LEGACY_AUTH_TYPE]), hash160(publicKey));
+    }
+    throw new Error(`Unsupported authType: 0x${String(authType).padStart(2, "0")}`);
+}
 function pqPublicKeyToAuthDescriptor(publicKey) {
-    return concatBytes(Uint8Array.from([PQ_AUTH_TYPE]), hash160(publicKey));
+    return buildAuthDescriptor(PQ_AUTH_TYPE, publicKey);
 }
 function pqPublicKeyToCommitment(publicKey, options = {}) {
     return pqPublicKeyToCommitmentParts(publicKey, options).commitment;
 }
-function pqPublicKeyToCommitmentParts(publicKey, options = {}) {
+function authScriptCommitmentParts(authType, publicKey, options = {}) {
     const witnessScript = normalizeWitnessScript(options.witnessScript);
-    const authDescriptor = pqPublicKeyToAuthDescriptor(publicKey);
+    const authDescriptor = buildAuthDescriptor(authType, publicKey);
     const witnessScriptHash = sha256Hash(witnessScript);
     const commitment = taggedHash(AUTHSCRIPT_TAG, concatBytes(Uint8Array.from([AUTHSCRIPT_VERSION]), authDescriptor, witnessScriptHash));
     return {
         authDescriptor,
-        authType: PQ_AUTH_TYPE,
+        authType,
         commitment,
         witnessScript,
     };
 }
+function pqPublicKeyToCommitmentParts(publicKey, options = {}) {
+    return authScriptCommitmentParts(PQ_AUTH_TYPE, publicKey, options);
+}
 function pqPublicKeyToAddressBytes(publicKey, network, options = {}) {
     return bech32mEncode(network.hrp, network.witnessVersion, pqPublicKeyToCommitment(publicKey, options));
 }
+function noAuthToAddressBytes(network, options = {}) {
+    return bech32mEncode(network.hrp, network.witnessVersion, authScriptCommitmentParts(NOAUTH_TYPE, null, options).commitment);
+}
+function legacyAuthScriptToAddressBytes(publicKey, network, options = {}) {
+    return bech32mEncode(network.hrp, network.witnessVersion, authScriptCommitmentParts(LEGACY_AUTH_TYPE, publicKey, options).commitment);
+}
 function normalizePublicKey(input) {
     return ensureBytes(input);
 }
@@ -481,6 +523,122 @@ class HDKey {
     }
 }
 
+const PQ_SEED_KEY = utf8ToBytes("Neurai PQ seed");
+const PQ_PUBLIC_KEY_HEADER = 0x05;
+// 74-byte layout, padded to match BIP32 xprv so base58check yields "xpqp..."/"tpqp...":
+// depth(1) + fingerprint(4) + child(4) + chaincode(32) + padding(1=0x00) + pq_seed(32)
+const BIP32_PQ_EXTKEY_SIZE = 74;
+class PQHDKey {
+    constructor(depth, index, parentFingerprint, chainCode, pqSeed) {
+        this.depth = depth;
+        this.index = index;
+        this.parentFingerprint = parentFingerprint;
+        this.chainCode = chainCode;
+        this.pqSeed = pqSeed;
+    }
+    static fromMasterSeed(seed) {
+        const I = hmacSha512(PQ_SEED_KEY, seed);
+        return new PQHDKey(0, 0, new Uint8Array(4), I.slice(32, 64), I.slice(0, 32));
+    }
+    ensureKeypair() {
+        if (!this._publicKey || !this._secretKey) {
+            const { publicKey, secretKey } = ml_dsa44.keygen(this.pqSeed);
+            this._publicKey = publicKey;
+            this._secretKey = secretKey;
+        }
+    }
+    get publicKey() {
+        this.ensureKeypair();
+        return this._publicKey;
+    }
+    get secretKey() {
+        this.ensureKeypair();
+        return this._secretKey;
+    }
+    get fingerprint() {
+        return hash160(concatBytes(Uint8Array.from([PQ_PUBLIC_KEY_HEADER]), this.publicKey)).slice(0, 4);
+    }
+    deriveChild(index) {
+        if ((index & HARDENED_OFFSET) === 0) {
+            throw new Error("PQ-HD (NIP-022) requires hardened derivation at every level");
+        }
+        const data = concatBytes(Uint8Array.from([0x00]), this.pqSeed, uint32ToBytesBE(index >>> 0));
+        const I = hmacSha512(this.chainCode, data);
+        return new PQHDKey(this.depth + 1, index >>> 0, this.fingerprint, I.slice(32, 64), I.slice(0, 32));
+    }
+    encode() {
+        const out = new Uint8Array(BIP32_PQ_EXTKEY_SIZE);
+        out[0] = this.depth & 0xff;
+        out.set(this.parentFingerprint, 1);
+        out[5] = (this.index >>> 24) & 0xff;
+        out[6] = (this.index >>> 16) & 0xff;
+        out[7] = (this.index >>> 8) & 0xff;
+        out[8] = this.index & 0xff;
+        out.set(this.chainCode, 9);
+        out[41] = 0x00; // padding byte (aligns layout with BIP32 xprv)
+        out.set(this.pqSeed, 42);
+        return out;
+    }
+    encodeBase58Check(version) {
+        const versionBytes = Uint8Array.from([
+            (version >>> 24) & 0xff,
+            (version >>> 16) & 0xff,
+            (version >>> 8) & 0xff,
+            version & 0xff,
+        ]);
+        return base58CheckEncode(concatBytes(versionBytes, this.encode()));
+    }
+    static decode(raw, parentFingerprint) {
+        if (raw.length !== BIP32_PQ_EXTKEY_SIZE) {
+            throw new Error(`PQ extended key payload must be ${BIP32_PQ_EXTKEY_SIZE} bytes`);
+        }
+        if (raw[41] !== 0x00) {
+            throw new Error("PQ extended key padding byte (offset 41) must be 0x00");
+        }
+        const depth = raw[0];
+        const fingerprint = parentFingerprint ?? raw.slice(1, 5);
+        const index = ((raw[5] << 24) | (raw[6] << 16) | (raw[7] << 8) | raw[8]) >>> 0;
+        const chainCode = raw.slice(9, 41);
+        const pqSeed = raw.slice(42, 74);
+        return new PQHDKey(depth, index, Uint8Array.from(fingerprint.slice(0, 4)), chainCode, pqSeed);
+    }
+    static decodeBase58Check(extKey, expectedVersion) {
+        const payload = base58CheckDecode(extKey);
+        if (payload.length !== 4 + BIP32_PQ_EXTKEY_SIZE) {
+            throw new Error("Invalid PQ extended key length");
+        }
+        const version = ((payload[0] << 24) | (payload[1] << 16) | (payload[2] << 8) | payload[3]) >>> 0;
+        if (version !== (expectedVersion >>> 0)) {
+            throw new Error(`PQ extended key version mismatch (expected 0x${expectedVersion.toString(16)}, got 0x${version.toString(16)})`);
+        }
+        return PQHDKey.decode(payload.slice(4));
+    }
+    derive(path) {
+        const entries = path.split("/");
+        const root = entries[0];
+        if (root !== "m" && root !== "M" && root !== "m_pq" && root !== "M_pq") {
+            throw new Error('PQ path must start with "m_pq" (or "m")');
+        }
+        if (entries.length === 1) {
+            return this;
+        }
+        let current = this;
+        for (let i = 1; i < entries.length; i += 1) {
+            const entry = entries[i];
+            const hardened = entry.endsWith("'");
+            if (!hardened) {
+                throw new Error(`PQ-HD path requires hardened indices (got "${entry}")`);
+            }
+            const raw = Number.parseInt(entry.slice(0, -1), 10);
+            if (!Number.isFinite(raw) || raw < 0 || raw >= HARDENED_OFFSET) {
+                throw new Error(`Invalid PQ-HD index "${entry}"`);
+            }
+            current = current.deriveChild(raw + HARDENED_OFFSET);
+        }
+        return current;
+    }
+}
+
 const currentNetworks = {
     xna: {
         versions: {
@@ -526,7 +684,7 @@ const pqNetworks = {
         purpose: 100,
         coinType: 1900,
         changeIndex: 0,
-        bip32: { private: 76066276, public: 76067358 },
+        pqExtPrivVersion: 0x0488ac24, // "xpqp..." prefix, matches Neurai node chainparams.cpp
     },
     "xna-pq-test": {
         hrp: "tnq",
@@ -534,7 +692,7 @@ const pqNetworks = {
         purpose: 100,
         coinType: 1,
         changeIndex: 0,
-        bip32: { private: 70615956, public: 70617039 },
+        pqExtPrivVersion: 0x043581d5, // "tpqp..." prefix, matches Neurai node chainparams.cpp
     },
 };
 function getNetwork(name) {
@@ -625,36 +783,89 @@ function publicKeyToAddress(network, publicKey) {
 function generateAddress(network = "xna") {
     return generateAddressObject(network);
 }
-function getPQHDKey(network, mnemonic, passphrase = "") {
-    const chain = getPQNetwork(network);
+function getPQHDKey(_network, mnemonic, passphrase = "") {
     const seed = mnemonicToSeedBytes(mnemonicToSeedSync, mnemonic, passphrase);
-    return HDKey.fromMasterSeed(seed, chain.bip32);
+    return PQHDKey.fromMasterSeed(seed);
+}
+function pqExtendedPrivateKey(network, hdKey) {
+    return hdKey.encodeBase58Check(getPQNetwork(network).pqExtPrivVersion);
+}
+function pqHDKeyFromExtended(network, extKey) {
+    return PQHDKey.decodeBase58Check(extKey, getPQNetwork(network).pqExtPrivVersion);
 }
 function getPQAddressByPath(network, hdKey, path, options = {}) {
     const chain = getPQNetwork(network);
     const derived = hdKey.derive(path);
-    if (!derived.privateKey) {
-        throw new Error("Could not derive private key for path");
-    }
-    const seed32 = Uint8Array.from(derived.privateKey);
-    const { publicKey, secretKey } = ml_dsa44.keygen(seed32);
+    const publicKey = derived.publicKey;
+    const secretKey = derived.secretKey;
     const authScript = pqPublicKeyToCommitmentParts(publicKey, options);
     return {
         address: pqPublicKeyToAddressBytes(publicKey, chain, options),
-        authType: authScript.authType,
+        authType: 0x01,
         authDescriptor: bytesToHex(authScript.authDescriptor),
         commitment: bytesToHex(authScript.commitment),
         path,
         publicKey: bytesToHex(publicKey),
         privateKey: bytesToHex(secretKey),
-        seedKey: bytesToHex(seed32),
+        seedKey: bytesToHex(derived.pqSeed),
         witnessScript: bytesToHex(authScript.witnessScript),
     };
 }
+function getNoAuthAddress(network, options = {}) {
+    const chain = getPQNetwork(network);
+    const parts = authScriptCommitmentParts(0x00, null, options);
+    return {
+        address: noAuthToAddressBytes(chain, options),
+        authType: 0x00,
+        commitment: bytesToHex(parts.commitment),
+        witnessScript: bytesToHex(parts.witnessScript),
+    };
+}
+function getLegacyAuthScriptAddress(network, legacyNetwork, mnemonic, account, index, passphrase = "", options = {}) {
+    const pqChain = getPQNetwork(network);
+    const legacyChain = getNetwork(legacyNetwork);
+    const coinType = legacyChain.bip44;
+    const hdKey = getHDKey(legacyNetwork, mnemonic, passphrase);
+    const path = `m/44'/${coinType}'/${account}'/0/${index}`;
+    const derived = hdKey.derive(path);
+    if (!derived.privateKey) {
+        throw new Error("Could not derive private key for path");
+    }
+    const legacyObject = privateKeyToAddressObject(derived.privateKey, legacyChain, path);
+    const publicKeyBytes = ensureBytes(legacyObject.publicKey);
+    const parts = authScriptCommitmentParts(0x02, publicKeyBytes, options);
+    return {
+        address: legacyAuthScriptToAddressBytes(publicKeyBytes, pqChain, options),
+        path,
+        publicKey: legacyObject.publicKey,
+        privateKey: legacyObject.privateKey,
+        WIF: legacyObject.WIF,
+        authType: 0x02,
+        authDescriptor: bytesToHex(parts.authDescriptor),
+        commitment: bytesToHex(parts.commitment),
+        witnessScript: bytesToHex(parts.witnessScript),
+    };
+}
+function getLegacyAuthScriptAddressByWIF(network, wif, options = {}) {
+    const pqChain = getPQNetwork(network);
+    const publicKeyHex = publicKeyHexFromWIF(wif);
+    const publicKeyBytes = ensureBytes(publicKeyHex);
+    const parts = authScriptCommitmentParts(0x02, publicKeyBytes, options);
+    return {
+        address: legacyAuthScriptToAddressBytes(publicKeyBytes, pqChain, options),
+        publicKey: publicKeyHex,
+        privateKey: "",
+        WIF: wif,
+        authType: 0x02,
+        authDescriptor: bytesToHex(parts.authDescriptor),
+        commitment: bytesToHex(parts.commitment),
+        witnessScript: bytesToHex(parts.witnessScript),
+    };
+}
 function getPQAddress(network, mnemonic, account, index, passphrase = "", options = {}) {
     const chain = getPQNetwork(network);
     const hdKey = getPQHDKey(network, mnemonic, passphrase);
-    const path = `m/${chain.purpose}'/${chain.coinType}'/${account}'/${chain.changeIndex}/${index}`;
+    const path = `m_pq/${chain.purpose}'/${chain.coinType}'/${account}'/${chain.changeIndex}'/${index}'`;
     return getPQAddressByPath(network, hdKey, path, options);
 }
 function pqPublicKeyToAddress(network, publicKey, options = {}) {
@@ -703,11 +914,16 @@ const NeuraiKey = {
     getPQAddress,
     getPQAddressByPath,
     getPQHDKey,
+    pqExtendedPrivateKey,
+    pqHDKeyFromExtended,
+    getNoAuthAddress,
+    getLegacyAuthScriptAddress,
+    getLegacyAuthScriptAddressByWIF,
     pqPublicKeyToAddress,
     pqPublicKeyToAuthDescriptorHex,
     pqPublicKeyToCommitmentHex,
     generatePQAddressObject,
 };
 
-export { NeuraiKey as default, entropyToMnemonic, generateAddress, generateAddressObject, generateMnemonic, generatePQAddressObject, getAddressByPath, getAddressByWIF, getAddressPair, getCoinType, getHDKey, getPQAddress, getPQAddressByPath, getPQHDKey, getPubkeyByWIF, isMnemonicValid, pqPublicKeyToAddress, pqPublicKeyToAuthDescriptorHex, pqPublicKeyToCommitmentHex, publicKeyToAddress };
+export { BIP32_PQ_EXTKEY_SIZE, HDKey, PQHDKey, NeuraiKey as default, entropyToMnemonic, generateAddress, generateAddressObject, generateMnemonic, generatePQAddressObject, getAddressByPath, getAddressByWIF, getAddressPair, getCoinType, getHDKey, getLegacyAuthScriptAddress, getLegacyAuthScriptAddressByWIF, getNoAuthAddress, getPQAddress, getPQAddressByPath, getPQHDKey, getPubkeyByWIF, isMnemonicValid, pqExtendedPrivateKey, pqHDKeyFromExtended, pqPublicKeyToAddress, pqPublicKeyToAuthDescriptorHex, pqPublicKeyToCommitmentHex, publicKeyToAddress };
 //# sourceMappingURL=index.js.map