@neuraiproject/neurai-key 3.0.2 → 3.1.0

package/dist/index.cjs

@@ -23717,7 +23717,10 @@ var distExports = requireDist();
 
 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 = Uint8Array.from([0x05]);
 const DEFAULT_WITNESS_SCRIPT = Uint8Array.from([0x51]);
 function encodeWIF(privateKey, version, compressed = true) {
     const payload = compressed
@@ -23778,27 +23781,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, 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);
 }
@@ -24068,7 +24095,7 @@ function getPQAddressByPath(network, hdKey, path, options = {}) {
     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,
@@ -24078,6 +24105,57 @@ function getPQAddressByPath(network, hdKey, path, options = {}) {
         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);
@@ -24130,6 +24208,9 @@ const NeuraiKey = {
     getPQAddress,
     getPQAddressByPath,
     getPQHDKey,
+    getNoAuthAddress,
+    getLegacyAuthScriptAddress,
+    getLegacyAuthScriptAddressByWIF,
     pqPublicKeyToAddress,
     pqPublicKeyToAuthDescriptorHex,
     pqPublicKeyToCommitmentHex,
@@ -24147,6 +24228,9 @@ exports.getAddressByWIF = getAddressByWIF;
 exports.getAddressPair = getAddressPair;
 exports.getCoinType = getCoinType;
 exports.getHDKey = getHDKey;
+exports.getLegacyAuthScriptAddress = getLegacyAuthScriptAddress;
+exports.getLegacyAuthScriptAddressByWIF = getLegacyAuthScriptAddressByWIF;
+exports.getNoAuthAddress = getNoAuthAddress;
 exports.getPQAddress = getPQAddress;
 exports.getPQAddressByPath = getPQAddressByPath;
 exports.getPQHDKey = getPQHDKey;