xpi-ts 0.2.13 → 0.2.15

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

@@ -0,0 +1,16 @@
+import { Input } from '../input';
+export class TaprootInput extends Input {
+    internalPubKey;
+    merkleRoot;
+    controlBlock;
+    tapScript;
+    constructor(data) {
+        super(data);
+        if (data) {
+            this.internalPubKey = data.internalPubKey;
+            this.merkleRoot = data.merkleRoot;
+            this.controlBlock = data.controlBlock;
+            this.tapScript = data.tapScript;
+        }
+    }
+}

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

@@ -1,37 +1,29 @@
-import { Preconditions } from '../util/preconditions.js';
-import { BitcoreError } from '../errors.js';
-import { BufferWriter } from '../encoding/bufferwriter.js';
-import { BufferUtil } from '../util/buffer.js';
-import { JSUtil } from '../util/js.js';
-import { Script, empty } from '../script.js';
-import { Opcode } from '../opcode.js';
-import { BN } from '../crypto/bn.js';
-import { Output } from './output.js';
-import { Signature } from '../crypto/signature.js';
-import { TransactionSignature } from './signature.js';
-import { sign, verify } from './sighash.js';
-import { Hash } from '../crypto/hash.js';
-import { tweakPrivateKey, TAPROOT_SIGHASH_TYPE, extractTaprootCommitment, } from '../taproot.js';
-import { musigNonceAgg, musigSigAgg } from '../crypto/musig2.js';
+import { Preconditions } from '../util/preconditions';
+import { BitcoreError } from '../errors';
+import { BufferWriter } from '../encoding/bufferwriter';
+import { BufferUtil } from '../util/buffer';
+import { JSUtil } from '../util/js';
+import { Script } from '../script';
+import { Opcode } from '../opcode';
+import { BN, Hash } from '../crypto';
+import { Output } from './output';
+import { muSig2NonceAgg, muSig2SigAgg } from '../crypto/musig2';
+import { Signature } from '../crypto/signature';
+import { TransactionSignature } from './signature';
+import { sign, verify } from './sighash';
+import { tweakPrivateKey, TAPROOT_SIGHASH_TYPE, extractTaprootCommitment, } from '../script/taproot';
+const NULL_INDEX = 0xffffffff;
+const NULL_HASH = BufferUtil.alloc(32);
 export class Input {
     static MAXINT = 0xffffffff;
     static DEFAULT_SEQNUMBER = 0xffffffff;
     static DEFAULT_LOCKTIME_SEQNUMBER = 0xfffffffe;
     static DEFAULT_RBF_SEQNUMBER = 0xfffffffd;
-    static SEQUENCE_LOCKTIME_TYPE_FLAG = 0x400000;
-    static SEQUENCE_LOCKTIME_DISABLE_FLAG = 0x80000000;
-    static SEQUENCE_LOCKTIME_MASK = 0xffff;
+    static SEQUENCE_LOCKTIME_DISABLE_FLAG = 1 << 31;
+    static SEQUENCE_LOCKTIME_TYPE_FLAG = 1 << 22;
+    static SEQUENCE_LOCKTIME_MASK = 0x0000ffff;
     static SEQUENCE_LOCKTIME_GRANULARITY = 512;
     static SEQUENCE_BLOCKDIFF_LIMIT = 0xffff;
-    static PublicKey;
-    static PublicKeyHash;
-    static Multisig;
-    static MultisigScriptHash;
-    static Taproot;
-    static MuSigTaproot;
-    static P2PKH;
-    static P2SH;
-    static P2TR;
     prevTxId;
     outputIndex;
     sequenceNumber;
@@ -54,13 +46,13 @@ export class Input {
     _fromObject(params) {
         let prevTxId;
         if (typeof params.prevTxId === 'string' && JSUtil.isHexa(params.prevTxId)) {
-            prevTxId = Buffer.from(params.prevTxId, 'hex');
+            prevTxId = BufferUtil.from(params.prevTxId, 'hex');
         }
-        else if (Buffer.isBuffer(params.prevTxId)) {
+        else if (BufferUtil.isBuffer(params.prevTxId)) {
             prevTxId = params.prevTxId;
         }
         else {
-            prevTxId = Buffer.alloc(0);
+            prevTxId = BufferUtil.alloc(0);
         }
         this.output = params.output;
         this.prevTxId = prevTxId;
@@ -95,20 +87,20 @@ export class Input {
             this._scriptBuffer = script.toBuffer();
         }
         else if (script === null) {
-            this._script = empty();
+            this._script = Script.empty();
             this._scriptBuffer = this._script.toBuffer();
         }
-        else if (Buffer.isBuffer(script)) {
+        else if (BufferUtil.isBuffer(script)) {
             this._scriptBuffer = script;
             this._script = Script.fromBuffer(script);
         }
         else if (typeof script === 'string') {
             if (JSUtil.isHexa(script)) {
-                this._scriptBuffer = Buffer.from(script, 'hex');
+                this._scriptBuffer = BufferUtil.from(script, 'hex');
                 this._script = Script.fromBuffer(this._scriptBuffer);
             }
             else {
-                this._scriptBuffer = Buffer.from(script, 'utf8');
+                this._scriptBuffer = BufferUtil.from(script, 'utf8');
                 this._script = Script.fromBuffer(this._scriptBuffer);
             }
         }
@@ -118,12 +110,10 @@ export class Input {
         return this;
     }
     isNull() {
-        return (this.prevTxId.toString('hex') ===
-            '0000000000000000000000000000000000000000000000000000000000000000' &&
-            this.outputIndex === 0xffffffff);
+        return this.prevTxId === NULL_HASH && this.outputIndex === NULL_INDEX;
     }
     isFinal() {
-        return this.sequenceNumber !== 4294967295;
+        return this.sequenceNumber !== Input.DEFAULT_SEQNUMBER;
     }
     hasSequence() {
         return this.sequenceNumber !== Input.DEFAULT_SEQNUMBER;
@@ -160,7 +150,7 @@ export class Input {
     }
     toObject() {
         const obj = {
-            prevTxId: Buffer.from(this.prevTxId).toString('hex'),
+            prevTxId: BufferUtil.from(this.prevTxId).toString('hex'),
             outputIndex: this.outputIndex,
             sequenceNumber: this.sequenceNumber,
             script: this._scriptBuffer.toString('hex'),
@@ -176,7 +166,9 @@ export class Input {
         }
         return obj;
     }
-    toJSON = this.toObject;
+    toJSON() {
+        return this.toObject();
+    }
     static fromBufferReader(br) {
         const input = new Input();
         input.prevTxId = br.readReverse(32);
@@ -218,15 +210,15 @@ export class Input {
         }
         return (this.prevTxId.length === 32 &&
             this.outputIndex >= 0 &&
-            this.outputIndex <= 0xffffffff &&
+            this.outputIndex <= NULL_INDEX &&
             this._scriptBuffer.length > 0);
     }
     clone() {
         return new Input({
-            prevTxId: Buffer.from(this.prevTxId),
+            prevTxId: BufferUtil.from(this.prevTxId),
             outputIndex: this.outputIndex,
             sequenceNumber: this.sequenceNumber,
-            scriptBuffer: Buffer.from(this._scriptBuffer),
+            scriptBuffer: BufferUtil.from(this._scriptBuffer),
             output: this.output,
         });
     }
@@ -445,9 +437,9 @@ export class MultisigInput extends Input {
         return this.signatures
             .filter(signature => signature !== undefined)
             .map(signature => {
-            return Buffer.concat([
+            return BufferUtil.concat([
                 signature.signature.toDER(signingMethod),
-                Buffer.from([signature.sigtype]),
+                BufferUtil.from([signature.sigtype]),
             ]);
         });
     }
@@ -617,9 +609,9 @@ export class MultisigScriptHashInput extends Input {
         return this.signatures
             .filter(signature => signature !== undefined)
             .map(signature => {
-            return Buffer.concat([
+            return BufferUtil.concat([
                 signature.signature.toDER(signingMethod),
-                Buffer.from([signature.sigtype]),
+                BufferUtil.from([signature.sigtype]),
             ]);
         });
     }
@@ -740,25 +732,23 @@ export class TaprootInput extends Input {
     tapScript;
     constructor(params) {
         super(params);
-        if (params) {
-            this.internalPubKey = params.internalPubKey;
-            this.merkleRoot = params.merkleRoot;
-            this.controlBlock = params.controlBlock;
-            this.tapScript = params.tapScript;
-        }
+        this.internalPubKey = params.internalPubKey;
+        this.merkleRoot = params.merkleRoot;
+        this.controlBlock = params.controlBlock;
+        this.tapScript = params.tapScript;
     }
     hasScriptTree() {
         if (!this.merkleRoot || this.merkleRoot.length !== 32) {
             return false;
         }
-        return !this.merkleRoot.equals(Buffer.alloc(32));
+        return !this.merkleRoot.equals(BufferUtil.alloc(32));
     }
     isKeyPathOnly() {
         return !this.hasScriptTree();
     }
     getSignatures(transaction, privateKey, index, sigtype, hashData, signingMethod) {
         Preconditions.checkState(this.output instanceof Output, 'Output is required');
-        Preconditions.checkState(this.output.script.isPayToTaproot(), 'Output must be Pay-To-Taproot');
+        Preconditions.checkState(this.output.script.isTaprootOut(), 'Output must be Pay-To-Taproot');
         const isKeyPath = this.isKeyPathOnly();
         if (isKeyPath) {
             sigtype = sigtype || TAPROOT_SIGHASH_TYPE;
@@ -778,7 +768,7 @@ export class TaprootInput extends Input {
         }
     }
     _getKeyPathSignatures(transaction, privateKey, index, sigtype, signingMethod) {
-        const merkleRoot = this.merkleRoot || Buffer.alloc(32);
+        const merkleRoot = this.merkleRoot || BufferUtil.alloc(32);
         const tweakedPrivateKey = tweakPrivateKey(privateKey, merkleRoot);
         const signature = sign(transaction, tweakedPrivateKey, sigtype, index, this.output.script, new BN(this.output.satoshis.toString()), undefined, signingMethod);
         return [
@@ -846,7 +836,7 @@ export class TaprootInput extends Input {
         return 66;
     }
 }
-export class MuSigTaprootInput extends TaprootInput {
+export class MuSig2TaprootInput extends TaprootInput {
     keyAggContext;
     publicNonces;
     aggregatedNonce;
@@ -854,14 +844,12 @@ export class MuSigTaprootInput extends TaprootInput {
     mySignerIndex;
     constructor(params) {
         super(params);
-        if (params) {
-            this.keyAggContext = params.keyAggContext;
-            this.mySignerIndex = params.mySignerIndex;
-            this.publicNonces = new Map();
-            this.partialSignatures = new Map();
-        }
+        this.keyAggContext = params.keyAggContext;
+        this.mySignerIndex = params.mySignerIndex;
+        this.publicNonces = new Map();
+        this.partialSignatures = new Map();
     }
-    initMuSigSession(keyAggContext, mySignerIndex) {
+    initMuSig2Session(keyAggContext, mySignerIndex) {
         this.keyAggContext = keyAggContext;
         this.mySignerIndex = mySignerIndex;
         this.publicNonces = new Map();
@@ -894,7 +882,7 @@ export class MuSigTaprootInput extends TaprootInput {
             }
             noncesArray.push(nonce);
         }
-        this.aggregatedNonce = musigNonceAgg(noncesArray);
+        this.aggregatedNonce = muSig2NonceAgg(noncesArray);
         return this;
     }
     addPartialSignature(signerIndex, partialSig) {
@@ -911,7 +899,7 @@ export class MuSigTaprootInput extends TaprootInput {
         const numSigners = this.keyAggContext.pubkeys.length;
         return this.partialSignatures.size === numSigners;
     }
-    finalizeMuSigSignature(transaction, message) {
+    finalizeMuSig2Signature(transaction, message) {
         if (!this.hasAllPartialSignatures()) {
             throw new Error('Not all partial signatures received');
         }
@@ -927,7 +915,7 @@ export class MuSigTaprootInput extends TaprootInput {
             }
             partialSigsArray.push(partialSig);
         }
-        const finalSignature = musigSigAgg(partialSigsArray, this.aggregatedNonce, message, commitment);
+        const finalSignature = muSig2SigAgg(partialSigsArray, this.aggregatedNonce, message, commitment);
         const script = new Script();
         script.add(finalSignature.toTxFormat('schnorr'));
         this.setScript(script);
@@ -940,12 +928,3 @@ export class MuSigTaprootInput extends TaprootInput {
                 this.script.chunks.length > 0));
     }
 }
-Input.PublicKey = PublicKeyInput;
-Input.PublicKeyHash = PublicKeyHashInput;
-Input.Multisig = MultisigInput;
-Input.MultisigScriptHash = MultisigScriptHashInput;
-Input.Taproot = TaprootInput;
-Input.MuSigTaproot = MuSigTaprootInput;
-Input.P2PKH = PublicKeyHashInput;
-Input.P2SH = MultisigScriptHashInput;
-Input.P2TR = TaprootInput;

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

@@ -0,0 +1,85 @@
+import { BufferReader } from '../encoding/bufferreader.js';
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { BufferUtil } from '../util/buffer.js';
+export const OUTPOINT_SIZE = 36;
+export class OutPoint {
+    static NULL_INDEX = 0xffffffff;
+    _txid;
+    _n;
+    constructor(txid, n) {
+        if (txid === undefined) {
+            this._txid = BufferUtil.alloc(32, 0);
+            this._n = OutPoint.NULL_INDEX;
+        }
+        else if (BufferUtil.isBuffer(txid)) {
+            if (txid.length !== 32) {
+                throw new TypeError(`OutPoint txid buffer must be 32 bytes, got ${txid.length}`);
+            }
+            this._txid = BufferUtil.from(txid);
+            this._n = n !== undefined ? n >>> 0 : OutPoint.NULL_INDEX;
+        }
+        else if (typeof txid === 'string') {
+            if (txid.length !== 64) {
+                throw new TypeError(`OutPoint txid hex string must be 64 characters, got ${txid.length}`);
+            }
+            this._txid = BufferUtil.reverse(BufferUtil.from(txid, 'hex'));
+            this._n = n !== undefined ? n >>> 0 : OutPoint.NULL_INDEX;
+        }
+        else {
+            throw new TypeError('OutPoint txid must be a Buffer or hex string');
+        }
+    }
+    static fromObject(data) {
+        return new OutPoint(data.txid, data.outputIndex);
+    }
+    static fromBuffer(buf) {
+        const reader = new BufferReader(buf);
+        return OutPoint.fromBufferReader(reader);
+    }
+    static fromBufferReader(reader) {
+        const txidBuf = reader.read(32);
+        const n = reader.readUInt32LE();
+        const outpoint = new OutPoint();
+        outpoint._txid = txidBuf;
+        outpoint._n = n;
+        return outpoint;
+    }
+    isNull() {
+        return (this._n === OutPoint.NULL_INDEX && this._txid.every(byte => byte === 0));
+    }
+    getTxId() {
+        return BufferUtil.reverse(this._txid).toString('hex');
+    }
+    getTxIdBuffer() {
+        return BufferUtil.from(this._txid);
+    }
+    getN() {
+        return this._n;
+    }
+    toBuffer() {
+        const writer = new BufferWriter();
+        this.toBufferWriter(writer);
+        return writer.toBuffer();
+    }
+    toBufferWriter(writer) {
+        writer.write(this._txid);
+        writer.writeUInt32LE(this._n);
+        return writer;
+    }
+    toObject() {
+        return {
+            txid: this.getTxId(),
+            outputIndex: this._n,
+        };
+    }
+    toString() {
+        return `COutPoint(${this.getTxId().substring(0, 10)}, ${this._n})`;
+    }
+    equals(other) {
+        return this._txid.equals(other._txid) && this._n === other._n;
+    }
+    lessThan(other) {
+        const cmp = this._txid.compare(other._txid);
+        return cmp < 0 || (cmp === 0 && this._n < other._n);
+    }
+}

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

@@ -1,9 +1,11 @@
+import { BN } from '../crypto/bn.js';
 import { Preconditions } from '../util/preconditions.js';
 import { BitcoreError } from '../errors.js';
 import { BufferWriter } from '../encoding/bufferwriter.js';
+import { BufferUtil } from '../util/buffer.js';
 import { JSUtil } from '../util/js.js';
 import { Script } from '../script.js';
-import { BN } from '../crypto/bn.js';
+import { Opcode } from '../opcode.js';
 const MAX_SAFE_INTEGER = 0x1fffffffffffff;
 export class Output {
     satoshis;
@@ -19,7 +21,7 @@ export class Output {
                 this.satoshis = 0;
                 this._satoshisBN = new BN(0);
             }
-            if (Buffer.isBuffer(args.script)) {
+            if (BufferUtil.isBuffer(args.script)) {
                 this._scriptBuffer = args.script;
             }
             else if (args.scriptBuffer !== undefined) {
@@ -29,7 +31,7 @@ export class Output {
                 this.setScript(args.script);
             }
             else {
-                this._scriptBuffer = Buffer.alloc(0);
+                this._scriptBuffer = BufferUtil.alloc(0);
             }
         }
         else {
@@ -108,7 +110,7 @@ export class Output {
             this._scriptBuffer = this._script.toBuffer();
             this._script._isOutput = true;
         }
-        else if (Buffer.isBuffer(script)) {
+        else if (BufferUtil.isBuffer(script)) {
             this.setScriptFromBuffer(script);
         }
         else {
@@ -150,7 +152,7 @@ export class Output {
         }
         return !!(this._script &&
             this._script.chunks.length > 0 &&
-            this._script.chunks[0].opcodenum === 0x6a);
+            this._script.chunks[0].opcodenum === Opcode.OP_RETURN);
     }
     toObject() {
         return {
@@ -178,7 +180,7 @@ export class Output {
             obj.script = br.read(size);
         }
         else {
-            obj.script = Buffer.from([]);
+            obj.script = BufferUtil.from([]);
         }
         return new Output(obj);
     }
@@ -214,10 +216,13 @@ export class Output {
         return new Output(data);
     }
     isPayToPublicKeyHash() {
-        return this.script.isPayToPublicKeyHash();
+        return this.script.isPublicKeyHashOut();
     }
     isPayToScriptHash() {
-        return this.script.isPayToScriptHash();
+        return this.script.isScriptHashOut();
+    }
+    isPayToTaproot() {
+        return this.script.isTaprootOut();
     }
     getAddress() {
         try {

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

@@ -1,23 +1,23 @@
-import { Signature } from '../crypto/signature.js';
-import { Script, empty } from '../script.js';
-import { Output } from './output.js';
-import { BufferReader } from '../encoding/bufferreader.js';
-import { BufferWriter } from '../encoding/bufferwriter.js';
-import { BN } from '../crypto/bn.js';
-import { Hash } from '../crypto/hash.js';
-import { ECDSA } from '../crypto/ecdsa.js';
-import { Schnorr } from '../crypto/schnorr.js';
-import { Preconditions } from '../util/preconditions.js';
-import { BufferUtil } from '../util/buffer.js';
-import { Interpreter } from '../script/interpreter.js';
-import { Transaction } from './transaction.js';
-import { Input } from './input.js';
+import { Signature } from '../crypto/signature';
+import { Script } from '../script';
+import { Output } from './output';
+import { BufferReader } from '../encoding/bufferreader';
+import { BufferWriter } from '../encoding/bufferwriter';
+import { BN } from '../crypto/bn';
+import { Hash } from '../crypto/hash';
+import { ECDSA } from '../crypto/ecdsa';
+import { Schnorr } from '../crypto/schnorr';
+import { Preconditions } from '../util/preconditions';
+import { BufferUtil } from '../util/buffer';
+import { Interpreter } from '../script/interpreter';
+import { Transaction } from './transaction';
+import { Input } from './input';
 const SIGHASH_SINGLE_BUG_CONST = '0000000000000000000000000000000000000000000000000000000000000001';
 const BITS_64_ON_CONST = 'ffffffffffffffff';
-const NULL_HASH = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
-const SIGHASH_ALGORITHM_MASK = 0x60;
+const NULL_HASH = BufferUtil.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+const SIGHASH_ALGORITHM_MASK = Signature.SIGHASH_ALGORITHM_MASK;
 const DEFAULT_SIGN_FLAGS_CONST = 1 << 16;
-function GetForkId() {
+function getForkId() {
     return 0;
 }
 function getMerkleRoot(hashes) {
@@ -32,7 +32,7 @@ function getMerkleRoot(hashes) {
         for (let i = 0; i < currentHashes.length; i += 2) {
             const left = currentHashes[i];
             const right = i + 1 < currentHashes.length ? currentHashes[i + 1] : NULL_HASH;
-            const combined = Buffer.concat([left, right]);
+            const combined = BufferUtil.concat([left, right]);
             const pairHash = Hash.sha256sha256(combined);
             newHashes.push(pairHash);
         }
@@ -224,7 +224,7 @@ function sighash(transaction, sighashType, inputNumber, subscript, satoshisBN, f
             prevTxId: txcopy.inputs[i].prevTxId,
             outputIndex: txcopy.inputs[i].outputIndex,
             sequenceNumber: txcopy.inputs[i].sequenceNumber,
-            script: empty(),
+            script: Script.empty(),
         });
     }
     txcopy.inputs[inputNumber] = new Input({
@@ -246,13 +246,13 @@ function sighash(transaction, sighashType, inputNumber, subscript, satoshisBN, f
     }
     else if ((sighashType & 31) === Signature.SIGHASH_SINGLE) {
         if (inputNumber >= txcopy.outputs.length) {
-            return Buffer.from(SIGHASH_SINGLE_BUG_CONST, 'hex');
+            return BufferUtil.from(SIGHASH_SINGLE_BUG_CONST, 'hex');
         }
         txcopy.outputs.length = inputNumber + 1;
         for (let i = 0; i < inputNumber; i++) {
             txcopy.outputs[i] = new Output({
-                satoshis: BN.fromBuffer(Buffer.from(BITS_64_ON_CONST, 'hex')),
-                script: empty(),
+                satoshis: BN.fromBuffer(BufferUtil.from(BITS_64_ON_CONST, 'hex')),
+                script: Script.empty(),
             });
         }
     }

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

@@ -1,9 +1,10 @@
-import { Preconditions } from '../util/preconditions.js';
-import { JSUtil } from '../util/js.js';
-import { PublicKey } from '../publickey.js';
-import { BitcoreError } from '../errors.js';
-import { Signature } from '../crypto/signature.js';
-import { isSchnorrSignature } from '../crypto/sigtype.js';
+import { Preconditions } from '../util/preconditions';
+import { BufferUtil } from '../util/buffer';
+import { JSUtil } from '../util/js';
+import { PublicKey } from '../publickey';
+import { BitcoreError } from '../errors';
+import { Signature } from '../crypto/signature';
+import { isSchnorrSignature } from '../crypto/sigtype';
 export class TransactionSignature {
     publicKey;
     prevTxId;
@@ -43,19 +44,19 @@ export class TransactionSignature {
     _fromObject(arg) {
         this._checkObjectArgs(arg);
         this.publicKey = new PublicKey(arg.publicKey);
-        this.prevTxId = Buffer.isBuffer(arg.prevTxId)
+        this.prevTxId = BufferUtil.isBuffer(arg.prevTxId)
             ? arg.prevTxId
-            : Buffer.from(arg.prevTxId, 'hex');
+            : BufferUtil.from(arg.prevTxId, 'hex');
         this.outputIndex = arg.outputIndex;
         this.inputIndex = arg.inputIndex;
         this._sigtype = arg.sigtype;
         if (arg.signature instanceof Signature) {
             this.signature = arg.signature;
         }
-        else if (Buffer.isBuffer(arg.signature)) {
+        else if (BufferUtil.isBuffer(arg.signature)) {
             const sigWithoutSighash = arg.signature.length > 64 &&
                 arg.signature[arg.signature.length - 1] !== 0x30
-                ? arg.signature.subarray(0, -1)
+                ? arg.signature.slice(0, -1)
                 : arg.signature;
             if (isSchnorrSignature(sigWithoutSighash)) {
                 const parsed = Signature.parseSchnorrEncodedSig(arg.signature);
@@ -68,10 +69,8 @@ export class TransactionSignature {
             }
         }
         else {
-            const buf = Buffer.from(arg.signature, 'hex');
-            const sigWithoutSighash = buf.length > 64 && buf[buf.length - 1] !== 0x30
-                ? buf.subarray(0, -1)
-                : buf;
+            const buf = BufferUtil.from(arg.signature, 'hex');
+            const sigWithoutSighash = buf.length > 64 && buf[buf.length - 1] !== 0x30 ? buf.slice(0, -1) : buf;
             if (isSchnorrSignature(sigWithoutSighash)) {
                 const parsed = Signature.parseSchnorrEncodedSig(buf);
                 const sig = new Signature(parsed.r, parsed.s);
@@ -93,9 +92,9 @@ export class TransactionSignature {
         Preconditions.checkArgument(arg.signature !== undefined, 'signature is required');
         Preconditions.checkArgument(arg.prevTxId !== undefined, 'prevTxId is required');
         Preconditions.checkState(arg.signature instanceof Signature ||
-            Buffer.isBuffer(arg.signature) ||
+            BufferUtil.isBuffer(arg.signature) ||
             JSUtil.isHexa(arg.signature), 'signature must be a buffer or hexa value');
-        Preconditions.checkState(Buffer.isBuffer(arg.prevTxId) || JSUtil.isHexa(arg.prevTxId), 'prevTxId must be a buffer or hexa value');
+        Preconditions.checkState(BufferUtil.isBuffer(arg.prevTxId) || JSUtil.isHexa(arg.prevTxId), 'prevTxId must be a buffer or hexa value');
         Preconditions.checkArgument(arg.sigtype !== undefined, 'sigtype is required');
         Preconditions.checkState(typeof arg.sigtype === 'number', 'sigtype must be a number');
     }
@@ -116,7 +115,7 @@ export class TransactionSignature {
     clone() {
         return new TransactionSignature({
             publicKey: this.publicKey,
-            prevTxId: Buffer.from(this.prevTxId),
+            prevTxId: BufferUtil.from(this.prevTxId),
             outputIndex: this.outputIndex,
             inputIndex: this.inputIndex,
             signature: this.signature,