@neuraiproject/neurai-key 3.0.0 → 3.0.2

package/dist/index.cjs

@@ -21504,6 +21504,13 @@ function uint32ToBytesBE(value) {
 function hash160(data) {
     return ripemd160(sha256(data));
 }
+function sha256Hash(data) {
+    return sha256(data);
+}
+function taggedHash(tag, data) {
+    const tagHash = sha256(utf8ToBytes(tag));
+    return sha256(concatBytes(tagHash, tagHash, data));
+}
 function doubleSha256(data) {
     return sha256(sha256(data));
 }
@@ -21544,7 +21551,6 @@ function mnemonicToSeedBytes(mnemonicToSeedSync, mnemonic, passphrase) {
     return Uint8Array.from(mnemonicToSeedSync(mnemonic, passphrase));
 }
 const BITCOIN_SEED_KEY = utf8ToBytes("Bitcoin seed");
-const HASH160_PREFIX = Uint8Array.from([0x05]);
 
 /**
  * Utils for modular division and fields.
@@ -23709,6 +23715,10 @@ function requireDist () {
 
 var distExports = requireDist();
 
+const AUTHSCRIPT_TAG = "NeuraiAuthScript";
+const AUTHSCRIPT_VERSION = 0x01;
+const PQ_AUTH_TYPE = 0x01;
+const DEFAULT_WITNESS_SCRIPT = Uint8Array.from([0x51]);
 function encodeWIF(privateKey, version, compressed = true) {
     const payload = compressed
         ? concatBytes(Uint8Array.from([version]), privateKey, Uint8Array.from([0x01]))
@@ -23765,9 +23775,29 @@ function publicKeyHexFromWIF(wif, compressed = true) {
 function bech32mEncode(hrp, witnessVersion, hash) {
     return distExports.bech32m.encode(hrp, [witnessVersion, ...distExports.bech32m.toWords(hash)]);
 }
-function pqPublicKeyToAddressBytes(publicKey, network) {
-    const serialized = concatBytes(HASH160_PREFIX, publicKey);
-    return bech32mEncode(network.hrp, network.witnessVersion, hash160(serialized));
+function normalizeWitnessScript(input) {
+    return input ? ensureBytes(input) : Uint8Array.from(DEFAULT_WITNESS_SCRIPT);
+}
+function pqPublicKeyToAuthDescriptor(publicKey) {
+    return concatBytes(Uint8Array.from([PQ_AUTH_TYPE]), hash160(publicKey));
+}
+function pqPublicKeyToCommitment(publicKey, options = {}) {
+    return pqPublicKeyToCommitmentParts(publicKey, options).commitment;
+}
+function pqPublicKeyToCommitmentParts(publicKey, options = {}) {
+    const witnessScript = normalizeWitnessScript(options.witnessScript);
+    const authDescriptor = pqPublicKeyToAuthDescriptor(publicKey);
+    const witnessScriptHash = sha256Hash(witnessScript);
+    const commitment = taggedHash(AUTHSCRIPT_TAG, concatBytes(Uint8Array.from([AUTHSCRIPT_VERSION]), authDescriptor, witnessScriptHash));
+    return {
+        authDescriptor,
+        authType: PQ_AUTH_TYPE,
+        commitment,
+        witnessScript,
+    };
+}
+function pqPublicKeyToAddressBytes(publicKey, network, options = {}) {
+    return bech32mEncode(network.hrp, network.witnessVersion, pqPublicKeyToCommitment(publicKey, options));
 }
 function normalizePublicKey(input) {
     return ensureBytes(input);
@@ -23929,8 +23959,8 @@ const pqNetworks = {
         hrp: "tnq",
         witnessVersion: 1,
         purpose: 100,
-        coinType: 1900,
-        changeIndex: 1,
+        coinType: 1,
+        changeIndex: 0,
         bip32: { private: 70615956, public: 70617039 },
     },
 };
@@ -24027,7 +24057,7 @@ function getPQHDKey(network, mnemonic, passphrase = "") {
     const seed = mnemonicToSeedBytes(mnemonicToSeedSync, mnemonic, passphrase);
     return HDKey.fromMasterSeed(seed, chain.bip32);
 }
-function getPQAddressByPath(network, hdKey, path) {
+function getPQAddressByPath(network, hdKey, path, options = {}) {
     const chain = getPQNetwork(network);
     const derived = hdKey.derive(path);
     if (!derived.privateKey) {
@@ -24035,30 +24065,50 @@ function getPQAddressByPath(network, hdKey, path) {
     }
     const seed32 = Uint8Array.from(derived.privateKey);
     const { publicKey, secretKey } = ml_dsa44.keygen(seed32);
+    const authScript = pqPublicKeyToCommitmentParts(publicKey, options);
     return {
-        address: pqPublicKeyToAddressBytes(publicKey, chain),
+        address: pqPublicKeyToAddressBytes(publicKey, chain, options),
+        authType: authScript.authType,
+        authDescriptor: bytesToHex(authScript.authDescriptor),
+        commitment: bytesToHex(authScript.commitment),
         path,
         publicKey: bytesToHex(publicKey),
         privateKey: bytesToHex(secretKey),
         seedKey: bytesToHex(seed32),
+        witnessScript: bytesToHex(authScript.witnessScript),
     };
 }
-function getPQAddress(network, mnemonic, account, index, passphrase = "") {
+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}`;
-    return getPQAddressByPath(network, hdKey, path);
+    return getPQAddressByPath(network, hdKey, path, options);
+}
+function pqPublicKeyToAddress(network, publicKey, options = {}) {
+    const keyBytes = ensureBytes(publicKey);
+    if (keyBytes.length !== 1312) {
+        throw new Error("ML-DSA-44 public key must be 1312 bytes");
+    }
+    normalizeWitnessScript(options.witnessScript);
+    return pqPublicKeyToAddressBytes(keyBytes, getPQNetwork(network), options);
+}
+function pqPublicKeyToCommitmentHex(publicKey, options = {}) {
+    const keyBytes = ensureBytes(publicKey);
+    if (keyBytes.length !== 1312) {
+        throw new Error("ML-DSA-44 public key must be 1312 bytes");
+    }
+    return bytesToHex(pqPublicKeyToCommitment(keyBytes, options));
 }
-function pqPublicKeyToAddress(network, publicKey) {
+function pqPublicKeyToAuthDescriptorHex(publicKey) {
     const keyBytes = ensureBytes(publicKey);
     if (keyBytes.length !== 1312) {
         throw new Error("ML-DSA-44 public key must be 1312 bytes");
     }
-    return pqPublicKeyToAddressBytes(keyBytes, getPQNetwork(network));
+    return bytesToHex(pqPublicKeyToAuthDescriptor(keyBytes));
 }
-function generatePQAddressObject(network = "xna-pq", passphrase = "") {
+function generatePQAddressObject(network = "xna-pq", passphrase = "", options = {}) {
     const mnemonic = generateMnemonic();
-    const addressObj = getPQAddress(network, mnemonic, 0, 0, passphrase);
+    const addressObj = getPQAddress(network, mnemonic, 0, 0, passphrase, options);
     return {
         ...addressObj,
         mnemonic,
@@ -24081,6 +24131,8 @@ const NeuraiKey = {
     getPQAddressByPath,
     getPQHDKey,
     pqPublicKeyToAddress,
+    pqPublicKeyToAuthDescriptorHex,
+    pqPublicKeyToCommitmentHex,
     generatePQAddressObject,
 };
 
@@ -24101,5 +24153,7 @@ exports.getPQHDKey = getPQHDKey;
 exports.getPubkeyByWIF = getPubkeyByWIF;
 exports.isMnemonicValid = isMnemonicValid;
 exports.pqPublicKeyToAddress = pqPublicKeyToAddress;
+exports.pqPublicKeyToAuthDescriptorHex = pqPublicKeyToAuthDescriptorHex;
+exports.pqPublicKeyToCommitmentHex = pqPublicKeyToCommitmentHex;
 exports.publicKeyToAddress = publicKeyToAddress;
 //# sourceMappingURL=index.cjs.map