xpi-ts 0.2.13 → 0.2.15

package/dist/esm/lib/bitcore/script.js

@@ -8,13 +8,17 @@ import { Address } from './address.js';
 import { BitcoreError } from './errors.js';
 import { BufferUtil } from './util/buffer.js';
 import { Signature } from './crypto/signature.js';
-import { Chunk } from './chunk.js';
-import { TAPROOT_SIZE_WITH_STATE, TAPROOT_SIZE_WITHOUT_STATE, } from './taproot.js';
+import { Chunk } from './script/chunk.js';
+import { PUBKEY_COMPRESSED_SIZE } from './script/taproot.js';
 export class Script {
     chunks;
     _network;
     constructor(from) {
-        if (Buffer.isBuffer(from)) {
+        if (!from) {
+            this.chunks = [];
+            return;
+        }
+        if (BufferUtil.isBuffer(from)) {
             return Script.fromBuffer(from);
         }
         else if (from instanceof Address) {
@@ -26,14 +30,9 @@ export class Script {
         else if (typeof from === 'string') {
             return Script.fromString(from);
         }
-        else if (typeof from === 'object' &&
-            from !== null &&
-            Array.isArray(from.chunks)) {
+        else if (typeof from === 'object' && Array.isArray(from.chunks)) {
             this.set(from);
         }
-        else {
-            this.chunks = [];
-        }
     }
     set(obj) {
         Preconditions.checkArgument(typeof obj === 'object', 'obj', 'Must be an object');
@@ -42,18 +41,25 @@ export class Script {
         this._network = obj._network;
         return this;
     }
+    static empty() {
+        return new Script();
+    }
     static fromBuffer(buffer) {
-        const script = new Script();
+        const script = Script.empty();
         script.chunks = [];
         const br = new BufferReader(buffer);
         while (!br.finished()) {
             try {
                 const opcodenum = br.readUInt8();
                 let len, buf;
-                if (opcodenum > 0 && opcodenum < Opcode.OP_PUSHDATA1) {
+                if (opcodenum >= 0 && opcodenum < Opcode.OP_PUSHDATA1) {
                     len = opcodenum;
+                    buf = br.read(len);
+                    if (buf.length !== len) {
+                        throw new BitcoreError.Script.InvalidBuffer(`Push data length mismatch: expected ${len}, got ${buf.length}`);
+                    }
                     script.chunks.push(new Chunk({
-                        buf: br.read(len),
+                        buf: buf,
                         len: len,
                         opcodenum: opcodenum,
                     }));
@@ -61,6 +67,9 @@ export class Script {
                 else if (opcodenum === Opcode.OP_PUSHDATA1) {
                     len = br.readUInt8();
                     buf = br.read(len);
+                    if (buf.length !== len) {
+                        throw new BitcoreError.Script.InvalidBuffer(`OP_PUSHDATA1 length mismatch: expected ${len}, got ${buf.length}`);
+                    }
                     script.chunks.push(new Chunk({
                         buf: buf,
                         len: len,
@@ -70,6 +79,9 @@ export class Script {
                 else if (opcodenum === Opcode.OP_PUSHDATA2) {
                     len = br.readUInt16LE();
                     buf = br.read(len);
+                    if (buf.length !== len) {
+                        throw new BitcoreError.Script.InvalidBuffer(`OP_PUSHDATA2 length mismatch: expected ${len}, got ${buf.length}`);
+                    }
                     script.chunks.push(new Chunk({
                         buf: buf,
                         len: len,
@@ -79,6 +91,9 @@ export class Script {
                 else if (opcodenum === Opcode.OP_PUSHDATA4) {
                     len = br.readUInt32LE();
                     buf = br.read(len);
+                    if (buf.length !== len) {
+                        throw new BitcoreError.Script.InvalidBuffer(`OP_PUSHDATA4 length mismatch: expected ${len}, got ${buf.length}`);
+                    }
                     script.chunks.push(new Chunk({
                         buf: buf,
                         len: len,
@@ -106,7 +121,7 @@ export class Script {
         if (!/^[0-9a-f]*$/.test(cleanStr)) {
             throw new BitcoreError.Script.InvalidScriptString(str);
         }
-        const buffer = Buffer.from(cleanStr, 'hex');
+        const buffer = BufferUtil.from(cleanStr, 'hex');
         return Script.fromBuffer(buffer);
     }
     static fromASM(str) {
@@ -119,7 +134,7 @@ export class Script {
             const opcode = new Opcode(token);
             const opcodenum = opcode.num;
             if (opcodenum === undefined) {
-                const buf = Buffer.from(tokens[i], 'hex');
+                const buf = BufferUtil.from(tokens[i], 'hex');
                 let opcodenum;
                 const len = buf.length;
                 if (len >= 0 && len < Opcode.OP_PUSHDATA1) {
@@ -154,14 +169,14 @@ export class Script {
         return script;
     }
     static fromHex(str) {
-        return new Script(Buffer.from(str, 'hex'));
+        return new Script(BufferUtil.from(str, 'hex'));
     }
     static fromAddress(address) {
         if (typeof address === 'string') {
             address = Address.fromString(address);
         }
         if (address.isPayToTaproot()) {
-            return Script.buildPayToTaproot(address.hashBuffer);
+            return Script.buildTaprootOut(address.hashBuffer);
         }
         else if (address.isPayToScriptHash()) {
             return Script.buildScriptHashOut(address);
@@ -171,6 +186,55 @@ export class Script {
         }
         throw new BitcoreError.Script.UnrecognizedAddress(address);
     }
+    static fromPayload(scriptType, payload) {
+        const buf = typeof payload === 'string' ? BufferUtil.from(payload, 'hex') : payload;
+        switch (scriptType) {
+            case 'p2pk': {
+                if (buf.length !== 33 && buf.length !== 65) {
+                    throw new Error(`Invalid p2pk payload length: expected 33 (compressed) or 65 (uncompressed), got ${buf.length}`);
+                }
+                return Script.buildPublicKeyOut(new PublicKey(buf));
+            }
+            case 'p2pkh': {
+                if (buf.length !== 20) {
+                    throw new Error(`Invalid p2pkh payload length: expected 20, got ${buf.length}`);
+                }
+                const p2pkhScript = new Script();
+                p2pkhScript.chunks = [];
+                p2pkhScript
+                    .add(Opcode.OP_DUP)
+                    .add(Opcode.OP_HASH160)
+                    .add(buf)
+                    .add(Opcode.OP_EQUALVERIFY)
+                    .add(Opcode.OP_CHECKSIG);
+                return p2pkhScript;
+            }
+            case 'p2sh': {
+                if (buf.length !== 20) {
+                    throw new Error(`Invalid p2sh payload length: expected 20, got ${buf.length}`);
+                }
+                const p2shScript = new Script();
+                p2shScript.add(Opcode.OP_HASH160).add(buf).add(Opcode.OP_EQUAL);
+                return p2shScript;
+            }
+            case 'p2tr-commitment': {
+                if (buf.length !== 33) {
+                    throw new Error(`Invalid p2tr-commitment payload length: expected 33, got ${buf.length}`);
+                }
+                return Script.buildTaprootOut(buf);
+            }
+            case 'p2tr-state': {
+                throw new Error('Cannot reconstruct full script from p2tr-state payload alone; ' +
+                    'the commitment is required. Use p2tr-commitment payload instead.');
+            }
+            case 'other': {
+                return Script.fromBuffer(buf);
+            }
+            default: {
+                throw new Error(`Unknown script type: ${scriptType}`);
+            }
+        }
+    }
     static buildMultisigOut(publicKeys, threshold, opts = {}) {
         Preconditions.checkArgument(threshold <= publicKeys.length, 'threshold', 'Number of required signatures must be less than or equal to the number of public keys');
         const script = new Script();
@@ -313,13 +377,6 @@ export class Script {
         script.add((opts.cachedMultisig || Script.buildMultisigOut(pubkeys, threshold, opts)).toBuffer());
         return script;
     }
-    static buildWitnessMultisigOutFromScript(script) {
-        const scriptHash = Hash.sha256(script.toBuffer());
-        const witnessScript = new Script();
-        witnessScript.add(Opcode.OP_0);
-        witnessScript.add(scriptHash);
-        return witnessScript;
-    }
     static buildPublicKeyOut(pubkey) {
         const script = new Script();
         script.add(pubkey.toBuffer());
@@ -330,10 +387,10 @@ export class Script {
         let buffer;
         if (typeof data === 'string') {
             if (encoding === 'hex') {
-                buffer = Buffer.from(data, 'hex');
+                buffer = BufferUtil.from(data, 'hex');
             }
             else {
-                buffer = Buffer.from(data, 'utf8');
+                buffer = BufferUtil.from(data, 'utf8');
             }
         }
         else {
@@ -389,10 +446,10 @@ export class Script {
         script.add(publicKey.toBuffer());
         return script;
     }
-    static buildPayToTaproot(commitment, state) {
+    static buildTaprootOut(commitment, state) {
         Preconditions.checkArgument(commitment !== undefined, 'commitment', 'Must be defined');
         const commitmentBuf = commitment instanceof PublicKey ? commitment.toBuffer() : commitment;
-        if (commitmentBuf.length !== 33) {
+        if (commitmentBuf.length !== PUBKEY_COMPRESSED_SIZE) {
             throw new Error('Taproot commitment must be 33-byte compressed public key');
         }
         if (state && state.length !== 32) {
@@ -413,7 +470,7 @@ export class Script {
                 opcodenum: chunk.num,
             }));
         }
-        else if (Buffer.isBuffer(chunk)) {
+        else if (BufferUtil.isBuffer(chunk)) {
             const chunkObj = {
                 buf: chunk,
                 len: chunk.length,
@@ -443,6 +500,17 @@ export class Script {
         }
         return this;
     }
+    addTaprootState(state) {
+        if (state.length !== 32) {
+            throw new Error('Taproot state must be exactly 32 bytes');
+        }
+        if (this.chunks[3]) {
+            this.chunks[3].buf = state;
+            return this;
+        }
+        this.add(state);
+        return this;
+    }
     toBuffer() {
         const bw = new BufferWriter();
         for (const chunk of this.chunks) {
@@ -465,18 +533,6 @@ export class Script {
     toString() {
         return this.toBuffer().toString('hex');
     }
-    toP2PKH() {
-        if (!this.isPayToPublicKeyHash()) {
-            throw new Error('Script is not a P2PKH address');
-        }
-        return this.chunks[2].buf.toString('hex');
-    }
-    toP2SH() {
-        if (!this.isPayToScriptHash()) {
-            throw new Error('Script is not a P2SH address');
-        }
-        return this.chunks[1].buf.toString('hex');
-    }
     toASM() {
         let str = '';
         for (let i = 0; i < this.chunks.length; i++) {
@@ -555,53 +611,37 @@ export class Script {
         }
         return str;
     }
-    isPayToPublicKeyHash() {
+    isPublicKeyHashOut() {
         return (this.chunks.length === 5 &&
             this.chunks[0].opcodenum === Opcode.OP_DUP &&
             this.chunks[1].opcodenum === Opcode.OP_HASH160 &&
             this.chunks[2].opcodenum === 20 &&
-            this.chunks[2].buf.length === 20 &&
-            this.chunks[3].opcodenum === Opcode.OP_EQUALVERIFY &&
-            this.chunks[4].opcodenum === Opcode.OP_CHECKSIG);
-    }
-    isPublicKeyHashOut() {
-        return !!(this.chunks.length === 5 &&
-            this.chunks[0].opcodenum === Opcode.OP_DUP &&
-            this.chunks[1].opcodenum === Opcode.OP_HASH160 &&
-            this.chunks[2].buf &&
-            this.chunks[2].buf.length === 20 &&
+            this.chunks[2].buf?.length === 20 &&
             this.chunks[3].opcodenum === Opcode.OP_EQUALVERIFY &&
             this.chunks[4].opcodenum === Opcode.OP_CHECKSIG);
     }
-    isPayToScriptHash() {
+    isScriptHashOut() {
         return (this.chunks.length === 3 &&
             this.chunks[0].opcodenum === Opcode.OP_HASH160 &&
             this.chunks[1].opcodenum === 20 &&
-            this.chunks[1].buf.length === 20 &&
+            this.chunks[1].buf?.length === 20 &&
             this.chunks[2].opcodenum === Opcode.OP_EQUAL);
     }
-    isScriptHashOut() {
-        const buf = this.toBuffer();
-        return (buf.length === 23 &&
-            buf[0] === Opcode.OP_HASH160 &&
-            buf[1] === 0x14 &&
-            buf[buf.length - 1] === Opcode.OP_EQUAL);
-    }
-    isPayToTaproot() {
-        const buf = this.toBuffer();
-        if (buf.length < TAPROOT_SIZE_WITHOUT_STATE ||
-            buf[0] !== Opcode.OP_SCRIPTTYPE ||
-            buf[1] !== Opcode.OP_1 ||
-            buf[2] !== 33) {
+    isTaprootOut() {
+        if (this.chunks[0].opcodenum !== Opcode.OP_SCRIPTTYPE ||
+            this.chunks[1].opcodenum !== Opcode.OP_1) {
             return false;
         }
-        if (buf.length === TAPROOT_SIZE_WITHOUT_STATE) {
-            return true;
+        if (this.chunks.length === 3) {
+            return (this.chunks[2].opcodenum === 33 && this.chunks[2].buf?.length === 33);
         }
-        return buf.length === TAPROOT_SIZE_WITH_STATE && buf[36] === 32;
-    }
-    isTaprootOut() {
-        return this.isPayToTaproot();
+        if (this.chunks.length === 4) {
+            return (this.chunks[2].opcodenum === 33 &&
+                this.chunks[2].buf?.length === 33 &&
+                this.chunks[3].opcodenum === 32 &&
+                this.chunks[3].buf?.length === 32);
+        }
+        return false;
     }
     isTaprootIn() {
         if (this.chunks.length === 0) {
@@ -632,20 +672,45 @@ export class Script {
     getData() {
         if (this.isScriptHashOut()) {
             if (this.chunks[1] === undefined) {
-                return Buffer.alloc(0);
+                return BufferUtil.alloc(0);
             }
             else {
-                return Buffer.from(this.chunks[1].buf);
+                return BufferUtil.from(this.chunks[1].buf);
             }
         }
         if (this.isPublicKeyHashOut()) {
-            return Buffer.from(this.chunks[2].buf);
+            return BufferUtil.from(this.chunks[2].buf);
         }
-        if (this.isPayToTaproot()) {
-            return Buffer.from(this.chunks[2].buf);
+        if (this.isTaprootOut()) {
+            return BufferUtil.from(this.chunks[2].buf);
         }
         throw new Error('Unrecognized script type to get data from');
     }
+    getPayload() {
+        let type;
+        let payload;
+        if (this.isPublicKeyOut()) {
+            type = 'p2pk';
+            payload = BufferUtil.from(this.chunks[0].buf);
+        }
+        else if (this.isPublicKeyHashOut()) {
+            type = 'p2pkh';
+            payload = BufferUtil.from(this.chunks[2].buf);
+        }
+        else if (this.isScriptHashOut()) {
+            type = 'p2sh';
+            payload = BufferUtil.from(this.chunks[1].buf);
+        }
+        else if (this.isTaprootOut()) {
+            type = this.chunks.length === 4 ? 'p2tr-state' : 'p2tr-commitment';
+            payload = BufferUtil.from(this.chunks[2].buf);
+        }
+        else {
+            type = 'other';
+            payload = this.toBuffer();
+        }
+        return { type, payload, payloadHex: payload.toString('hex') };
+    }
     getAddressInfo() {
         if (this._isInput) {
             return this._getInputAddressInfo();
@@ -663,7 +728,7 @@ export class Script {
     }
     _getOutputAddressInfo() {
         const info = {};
-        if (this.isPayToTaproot()) {
+        if (this.isTaprootOut()) {
             const buf = this.toBuffer();
             info.hashBuffer = buf.slice(3, 36);
             info.type = Address.PayToTaproot;
@@ -703,7 +768,7 @@ export class Script {
         }
         if (info instanceof Address) {
             if (network) {
-                if (this.isPayToTaproot()) {
+                if (this.isTaprootOut()) {
                     const buf = this.toBuffer();
                     const commitment = buf.slice(3, 36);
                     return Address.fromTaprootCommitment(commitment, network);
@@ -758,7 +823,16 @@ export class Script {
     }
     isValid() {
         try {
-            return this.chunks.length > 0;
+            for (const chunk of this.chunks) {
+                if (chunk.opcodenum === undefined) {
+                    return false;
+                }
+                if (chunk.buf &&
+                    (chunk.len === undefined || chunk.len !== chunk.buf.length)) {
+                    return false;
+                }
+            }
+            return true;
         }
         catch (e) {
             return false;
@@ -768,7 +842,7 @@ export class Script {
         const cloned = new Script();
         cloned.chunks = this.chunks.map(chunk => new Chunk({
             opcodenum: chunk.opcodenum,
-            buf: chunk.buf ? Buffer.from(chunk.buf) : undefined,
+            buf: chunk.buf ? BufferUtil.from(chunk.buf) : undefined,
             len: chunk.len,
         }));
         return cloned;
@@ -859,7 +933,7 @@ export class Script {
         return (this.chunks.length > 3 &&
             this._isSmallIntOp(this.chunks[0].opcodenum) &&
             this.chunks.slice(1, this.chunks.length - 2).every(function (obj) {
-                return obj.buf && Buffer.isBuffer(obj.buf);
+                return obj.buf && BufferUtil.isBuffer(obj.buf);
             }) &&
             this._isSmallIntOp(this.chunks[this.chunks.length - 2].opcodenum) &&
             this.chunks[this.chunks.length - 1].opcodenum === Opcode.OP_CHECKMULTISIG);
@@ -871,7 +945,7 @@ export class Script {
         return (this.chunks.length >= 2 &&
             this.chunks[0].opcodenum === 0 &&
             this.chunks.slice(1, this.chunks.length).every(function (obj) {
-                return obj.buf && Buffer.isBuffer(obj.buf) && Signature.isTxDER(obj.buf);
+                return (obj.buf && BufferUtil.isBuffer(obj.buf) && Signature.isTxDER(obj.buf));
             }));
     }
     isDataOut() {
@@ -941,11 +1015,8 @@ export class Script {
         return this.classify() !== ScriptTypes.UNKNOWN;
     }
     getType() {
-        if (this.isPayToTaproot()) {
-            const buf = this.toBuffer();
-            return buf.length === TAPROOT_SIZE_WITH_STATE
-                ? 'p2tr-state'
-                : 'p2tr-commitment';
+        if (this.isTaprootOut()) {
+            return this.chunks.length === 4 ? 'p2tr-state' : 'p2tr-commitment';
         }
         else if (this.isPublicKeyOut()) {
             return 'p2pk';
@@ -968,11 +1039,11 @@ export class Script {
             return false;
         }
         for (let i = 0; i < this.chunks.length; i++) {
-            if (Buffer.isBuffer(this.chunks[i].buf) &&
-                !Buffer.isBuffer(script.chunks[i].buf)) {
+            if (BufferUtil.isBuffer(this.chunks[i].buf) &&
+                !BufferUtil.isBuffer(script.chunks[i].buf)) {
                 return false;
             }
-            if (Buffer.isBuffer(this.chunks[i].buf) &&
+            if (BufferUtil.isBuffer(this.chunks[i].buf) &&
                 !BufferUtil.equals(this.chunks[i].buf, script.chunks[i].buf)) {
                 return false;
             }
@@ -992,7 +1063,7 @@ export class Script {
         else if (obj instanceof Opcode) {
             this._addOpcode(obj, prepend);
         }
-        else if (Buffer.isBuffer(obj)) {
+        else if (BufferUtil.isBuffer(obj)) {
             this._addBuffer(obj, prepend);
         }
         else if (obj instanceof Script) {
@@ -1133,13 +1204,3 @@ export const ScriptTypes = {
     MULTISIG_IN: 'Spend from multisig',
     DATA_OUT: 'Data push',
 };
-export function toAddress(script, network) {
-    const addr = script.toAddress(network);
-    if (!addr || typeof addr === 'boolean') {
-        throw new Error('Cannot convert script to address');
-    }
-    return addr;
-}
-export function empty() {
-    return new Script();
-}

package/dist/esm/lib/bitcore/taproot/musig2.js

@@ -1,14 +1,15 @@
-import { Address } from '../address.js';
-import { BN, Point, Hash } from '../crypto/index.js';
-import { musigKeyAgg, musigPartialSign, musigPartialSigVerify, musigTaggedHash, MUSIG_TAG_NONCE_COEFF, } from '../crypto/musig2.js';
-import { buildKeyPathTaproot, buildScriptPathTaproot, calculateTapTweak, tweakPublicKey, } from '../taproot.js';
-export function buildMuSigTaprootKey(signerPubKeys, state) {
-    const keyAggContext = musigKeyAgg(signerPubKeys);
+import { Address } from '../address';
+import { BufferUtil } from '../util/buffer';
+import { BN, Point, Hash } from '../crypto/index';
+import { MUSIG2_TAG_NONCE_COEFF, muSig2KeyAgg, muSig2PartialSign, muSig2PartialSigVerify, muSig2TaggedHash, } from '../crypto/musig2';
+import { buildKeyPathTaproot, buildScriptPathTaproot, calculateTapTweak, tweakPublicKey, } from '../script/taproot';
+export function buildMuSig2TaprootKey(signerPubKeys) {
+    const keyAggContext = muSig2KeyAgg(signerPubKeys);
     const aggregatedPubKey = keyAggContext.aggregatedPubKey;
-    const merkleRoot = Buffer.alloc(32);
+    const merkleRoot = BufferUtil.alloc(32);
     const tweak = calculateTapTweak(aggregatedPubKey, merkleRoot);
     const commitment = tweakPublicKey(aggregatedPubKey, merkleRoot);
-    const script = buildKeyPathTaproot(aggregatedPubKey, state);
+    const script = buildKeyPathTaproot(aggregatedPubKey);
     return {
         aggregatedPubKey,
         commitment,
@@ -18,8 +19,8 @@ export function buildMuSigTaprootKey(signerPubKeys, state) {
         tweak,
     };
 }
-export function buildMuSigTaprootKeyWithScripts(signerPubKeys, scriptTree, state) {
-    const keyAggContext = musigKeyAgg(signerPubKeys);
+export function buildMuSig2TaprootKeyWithScripts(signerPubKeys, scriptTree, state) {
+    const keyAggContext = muSig2KeyAgg(signerPubKeys);
     const aggregatedPubKey = keyAggContext.aggregatedPubKey;
     const { script, commitment, merkleRoot, leaves } = buildScriptPathTaproot(aggregatedPubKey, scriptTree, state);
     const tweak = calculateTapTweak(aggregatedPubKey, merkleRoot);
@@ -40,22 +41,26 @@ export function signTaprootKeyPathWithMuSig2(secretNonce, privateKey, keyAggCont
         ...keyAggContext,
         aggregatedPubKey: commitment,
     };
-    const partialSig = musigPartialSign(secretNonce, privateKey, modifiedKeyAggContext, signerIndex, aggregatedNonce, message);
+    const partialSig = muSig2PartialSign(secretNonce, privateKey, modifiedKeyAggContext, signerIndex, aggregatedNonce, message);
     if (signerIndex === 0) {
         const { R1, R2 } = aggregatedNonce;
-        const nonceCoefData = Buffer.concat([
+        const nonceCoefData = BufferUtil.concat([
             commitment.toBuffer(),
             Point.pointToCompressed(R1),
             Point.pointToCompressed(R2),
             message,
         ]);
-        const b = new BN(musigTaggedHash(MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+        const b = BN.fromBuffer(muSig2TaggedHash(MUSIG2_TAG_NONCE_COEFF, nonceCoefData));
         const R = R1.add(R2.mul(b));
-        const R_x = R.getX().toArrayLike(Buffer, 'be', 32);
+        const R_x = R.x.toBuffer({ size: 32 });
         const commitment_compressed = Point.pointToCompressed(commitment.point);
-        const challengeData = Buffer.concat([R_x, commitment_compressed, message]);
-        const e = new BN(Hash.sha256(challengeData), 'be').umod(n);
-        const tweakBN = new BN(tweak, 'be').umod(n);
+        const challengeData = BufferUtil.concat([
+            R_x,
+            commitment_compressed,
+            message,
+        ]);
+        const e = BN.fromBuffer(Hash.sha256(challengeData)).umod(n);
+        const tweakBN = BN.fromBuffer(tweak).umod(n);
         const tweakTerm = e.mul(tweakBN).umod(n);
         return partialSig.add(tweakTerm).umod(n);
     }
@@ -71,28 +76,32 @@ export function verifyTaprootKeyPathMuSigPartial(partialSig, publicNonce, public
     let adjustedPartialSig = partialSig;
     if (signerIndex === 0) {
         const { R1, R2 } = aggregatedNonce;
-        const nonceCoefData = Buffer.concat([
+        const nonceCoefData = BufferUtil.concat([
             commitment.toBuffer(),
             Point.pointToCompressed(R1),
             Point.pointToCompressed(R2),
             message,
         ]);
-        const b = new BN(musigTaggedHash(MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+        const b = BN.fromBuffer(muSig2TaggedHash(MUSIG2_TAG_NONCE_COEFF, nonceCoefData));
         const R = R1.add(R2.mul(b));
-        const R_x = R.getX().toArrayLike(Buffer, 'be', 32);
+        const R_x = R.x.toBuffer({ size: 32 });
         const commitment_compressed = Point.pointToCompressed(commitment.point);
-        const challengeData = Buffer.concat([R_x, commitment_compressed, message]);
-        const e = new BN(Hash.sha256(challengeData), 'be').umod(n);
-        const tweakBN = new BN(tweak, 'be').umod(n);
+        const challengeData = BufferUtil.concat([
+            R_x,
+            commitment_compressed,
+            message,
+        ]);
+        const e = BN.fromBuffer(Hash.sha256(challengeData)).umod(n);
+        const tweakBN = BN.fromBuffer(tweak).umod(n);
         const tweakTerm = e.mul(tweakBN).umod(n);
         adjustedPartialSig = partialSig.sub(tweakTerm).umod(n);
     }
-    return musigPartialSigVerify(adjustedPartialSig, publicNonce, publicKey, modifiedKeyAggContext, signerIndex, aggregatedNonce, message);
+    return muSig2PartialSigVerify(adjustedPartialSig, publicNonce, publicKey, modifiedKeyAggContext, signerIndex, aggregatedNonce, message);
 }
 export function isMuSigTaprootOutput(script) {
-    return script.isPayToTaproot();
+    return script.isTaprootOut();
 }
-export function createMuSigTaprootAddress(signerPubKeys, network, state) {
+export function createMuSigTaprootAddress(signerPubKeys, network) {
     if (signerPubKeys.length === 0) {
         throw new Error('At least one signer public key is required');
     }
@@ -101,7 +110,7 @@ export function createMuSigTaprootAddress(signerPubKeys, network, state) {
     if (mismatchedKeyIndex !== -1) {
         throw new Error(`Public key network mismatch at index ${mismatchedKeyIndex}: expected '${inferredNetwork}', got '${signerPubKeys[mismatchedKeyIndex].network.name}'`);
     }
-    const result = buildMuSigTaprootKey(signerPubKeys, state);
+    const result = buildMuSig2TaprootKey(signerPubKeys);
     const address = Address.fromTaprootCommitment(result.commitment, inferredNetwork);
     return {
         address,

package/dist/esm/lib/bitcore/transaction/index.js

@@ -1,6 +1,6 @@
-export { Input, MultisigInput, MultisigScriptHashInput, PublicKeyInput, PublicKeyHashInput, TaprootInput, MuSigTaprootInput, } from './input.js';
-export { Output } from './output.js';
-export { UnspentOutput } from './unspentoutput.js';
-export { sighash, sign, verify } from './sighash.js';
-export { TransactionSignature } from './signature.js';
-export { Transaction } from './transaction.js';
+export { Input, MultisigInput, MultisigScriptHashInput, PublicKeyInput, PublicKeyHashInput, TaprootInput, MuSig2TaprootInput, } from './input';
+export { Output } from './output';
+export { UnspentOutput } from './unspentoutput';
+export { sighash, sign, verify } from './sighash';
+export { TransactionSignature } from './signature';
+export { Transaction } from './transaction';

package/dist/esm/lib/bitcore/transaction/input/multisig.js

@@ -0,0 +1,6 @@
+import { Input } from '../input';
+export class MultisigInput extends Input {
+    constructor(data) {
+        super(data);
+    }
+}

package/dist/esm/lib/bitcore/transaction/input/multisigscripthash.js

@@ -0,0 +1,6 @@
+import { Input } from '../input';
+export class MultisigScriptHashInput extends Input {
+    constructor(data) {
+        super(data);
+    }
+}

package/dist/esm/lib/bitcore/transaction/input/publickey.js

@@ -0,0 +1,6 @@
+import { Input } from '../input';
+export class PublicKeyInput extends Input {
+    constructor(data) {
+        super(data);
+    }
+}

package/dist/esm/lib/bitcore/transaction/input/publickeyhash.js

@@ -0,0 +1,6 @@
+import { Input } from '../input';
+export class PublicKeyHashInput extends Input {
+    constructor(data) {
+        super(data);
+    }
+}