xpi-ts 0.2.13 → 0.2.15

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutPoint = exports.OUTPOINT_SIZE = void 0;
+const bufferreader_js_1 = require("../encoding/bufferreader.js");
+const bufferwriter_js_1 = require("../encoding/bufferwriter.js");
+const buffer_js_1 = require("../util/buffer.js");
+exports.OUTPOINT_SIZE = 36;
+class OutPoint {
+    static NULL_INDEX = 0xffffffff;
+    _txid;
+    _n;
+    constructor(txid, n) {
+        if (txid === undefined) {
+            this._txid = buffer_js_1.BufferUtil.alloc(32, 0);
+            this._n = OutPoint.NULL_INDEX;
+        }
+        else if (buffer_js_1.BufferUtil.isBuffer(txid)) {
+            if (txid.length !== 32) {
+                throw new TypeError(`OutPoint txid buffer must be 32 bytes, got ${txid.length}`);
+            }
+            this._txid = buffer_js_1.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 = buffer_js_1.BufferUtil.reverse(buffer_js_1.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_js_1.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 buffer_js_1.BufferUtil.reverse(this._txid).toString('hex');
+    }
+    getTxIdBuffer() {
+        return buffer_js_1.BufferUtil.from(this._txid);
+    }
+    getN() {
+        return this._n;
+    }
+    toBuffer() {
+        const writer = new bufferwriter_js_1.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);
+    }
+}
+exports.OutPoint = OutPoint;

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

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Output = void 0;
+const bn_js_1 = require("../crypto/bn.js");
 const preconditions_js_1 = require("../util/preconditions.js");
 const errors_js_1 = require("../errors.js");
 const bufferwriter_js_1 = require("../encoding/bufferwriter.js");
+const buffer_js_1 = require("../util/buffer.js");
 const js_js_1 = require("../util/js.js");
 const script_js_1 = require("../script.js");
-const bn_js_1 = require("../crypto/bn.js");
+const opcode_js_1 = require("../opcode.js");
 const MAX_SAFE_INTEGER = 0x1fffffffffffff;
 class Output {
     satoshis;
@@ -22,7 +24,7 @@ class Output {
                 this.satoshis = 0;
                 this._satoshisBN = new bn_js_1.BN(0);
             }
-            if (Buffer.isBuffer(args.script)) {
+            if (buffer_js_1.BufferUtil.isBuffer(args.script)) {
                 this._scriptBuffer = args.script;
             }
             else if (args.scriptBuffer !== undefined) {
@@ -32,7 +34,7 @@ class Output {
                 this.setScript(args.script);
             }
             else {
-                this._scriptBuffer = Buffer.alloc(0);
+                this._scriptBuffer = buffer_js_1.BufferUtil.alloc(0);
             }
         }
         else {
@@ -111,7 +113,7 @@ class Output {
             this._scriptBuffer = this._script.toBuffer();
             this._script._isOutput = true;
         }
-        else if (Buffer.isBuffer(script)) {
+        else if (buffer_js_1.BufferUtil.isBuffer(script)) {
             this.setScriptFromBuffer(script);
         }
         else {
@@ -153,7 +155,7 @@ class Output {
         }
         return !!(this._script &&
             this._script.chunks.length > 0 &&
-            this._script.chunks[0].opcodenum === 0x6a);
+            this._script.chunks[0].opcodenum === opcode_js_1.Opcode.OP_RETURN);
     }
     toObject() {
         return {
@@ -181,7 +183,7 @@ class Output {
             obj.script = br.read(size);
         }
         else {
-            obj.script = Buffer.from([]);
+            obj.script = buffer_js_1.BufferUtil.from([]);
         }
         return new Output(obj);
     }
@@ -217,10 +219,13 @@ 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/cjs/lib/bitcore/transaction/sighash.js

@@ -4,26 +4,26 @@ exports.BITS_64_ON = exports.SIGHASH_SINGLE_BUG = exports.DEFAULT_SIGN_FLAGS = v
 exports.sighash = sighash;
 exports.sign = sign;
 exports.verify = verify;
-const signature_js_1 = require("../crypto/signature.js");
-const script_js_1 = require("../script.js");
-const output_js_1 = require("./output.js");
-const bufferreader_js_1 = require("../encoding/bufferreader.js");
-const bufferwriter_js_1 = require("../encoding/bufferwriter.js");
-const bn_js_1 = require("../crypto/bn.js");
-const hash_js_1 = require("../crypto/hash.js");
-const ecdsa_js_1 = require("../crypto/ecdsa.js");
-const schnorr_js_1 = require("../crypto/schnorr.js");
-const preconditions_js_1 = require("../util/preconditions.js");
-const buffer_js_1 = require("../util/buffer.js");
-const interpreter_js_1 = require("../script/interpreter.js");
-const transaction_js_1 = require("./transaction.js");
-const input_js_1 = require("./input.js");
+const signature_1 = require("../crypto/signature");
+const script_1 = require("../script");
+const output_1 = require("./output");
+const bufferreader_1 = require("../encoding/bufferreader");
+const bufferwriter_1 = require("../encoding/bufferwriter");
+const bn_1 = require("../crypto/bn");
+const hash_1 = require("../crypto/hash");
+const ecdsa_1 = require("../crypto/ecdsa");
+const schnorr_1 = require("../crypto/schnorr");
+const preconditions_1 = require("../util/preconditions");
+const buffer_1 = require("../util/buffer");
+const interpreter_1 = require("../script/interpreter");
+const transaction_1 = require("./transaction");
+const input_1 = require("./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 = buffer_1.BufferUtil.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+const SIGHASH_ALGORITHM_MASK = signature_1.Signature.SIGHASH_ALGORITHM_MASK;
 const DEFAULT_SIGN_FLAGS_CONST = 1 << 16;
-function GetForkId() {
+function getForkId() {
     return 0;
 }
 function getMerkleRoot(hashes) {
@@ -38,8 +38,8 @@ 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 pairHash = hash_js_1.Hash.sha256sha256(combined);
+            const combined = buffer_1.BufferUtil.concat([left, right]);
+            const pairHash = hash_1.Hash.sha256sha256(combined);
             newHashes.push(pairHash);
         }
         currentHashes = newHashes;
@@ -47,107 +47,107 @@ function getMerkleRoot(hashes) {
     return { root: currentHashes[0], height };
 }
 function sighashForLotus(transaction, sighashType, inputNumber, spentOutputs, executedScriptHash, codeseparatorPos = 0xffffffff) {
-    preconditions_js_1.Preconditions.checkArgument(spentOutputs.length === transaction.inputs.length, 'Must provide spent output for each input');
-    preconditions_js_1.Preconditions.checkArgument(inputNumber < transaction.inputs.length, 'Input index out of range');
+    preconditions_1.Preconditions.checkArgument(spentOutputs.length === transaction.inputs.length, 'Must provide spent output for each input');
+    preconditions_1.Preconditions.checkArgument(inputNumber < transaction.inputs.length, 'Input index out of range');
     const baseType = sighashType & 0x03;
     const unusedBits = sighashType & 0x1c;
     if (baseType === 0 || unusedBits !== 0) {
         throw new Error('Invalid sighash type for SIGHASH_LOTUS');
     }
     const input = transaction.inputs[inputNumber];
-    const writer = new bufferwriter_js_1.BufferWriter();
+    const writer = new bufferwriter_1.BufferWriter();
     writer.writeUInt32LE(sighashType >>> 0);
     const spendType = executedScriptHash ? 2 : 0;
-    const inputHashWriter = new bufferwriter_js_1.BufferWriter();
+    const inputHashWriter = new bufferwriter_1.BufferWriter();
     inputHashWriter.writeUInt8(spendType);
     inputHashWriter.writeReverse(input.prevTxId);
     inputHashWriter.writeUInt32LE(input.outputIndex);
     inputHashWriter.writeUInt32LE(input.sequenceNumber);
     const spentOutput = spentOutputs[inputNumber];
-    inputHashWriter.writeUInt64LEBN(new bn_js_1.BN(spentOutput.satoshis));
+    inputHashWriter.writeUInt64LEBN(new bn_1.BN(spentOutput.satoshis));
     inputHashWriter.writeVarLengthBuffer(spentOutput.scriptBuffer);
-    const inputHash = hash_js_1.Hash.sha256sha256(inputHashWriter.toBuffer());
+    const inputHash = hash_1.Hash.sha256sha256(inputHashWriter.toBuffer());
     writer.write(inputHash);
     if (executedScriptHash) {
-        preconditions_js_1.Preconditions.checkArgument(executedScriptHash.length === 32, 'executed_script_hash must be 32 bytes');
+        preconditions_1.Preconditions.checkArgument(executedScriptHash.length === 32, 'executed_script_hash must be 32 bytes');
         writer.writeUInt32LE(codeseparatorPos);
         writer.write(executedScriptHash);
     }
-    if (!(sighashType & signature_js_1.Signature.SIGHASH_ANYONECANPAY)) {
+    if (!(sighashType & signature_1.Signature.SIGHASH_ANYONECANPAY)) {
         writer.writeUInt32LE(inputNumber);
         const spentOutputHashes = spentOutputs.map(output => {
-            const w = new bufferwriter_js_1.BufferWriter();
-            w.writeUInt64LEBN(new bn_js_1.BN(output.satoshis));
+            const w = new bufferwriter_1.BufferWriter();
+            w.writeUInt64LEBN(new bn_1.BN(output.satoshis));
             w.writeVarLengthBuffer(output.scriptBuffer);
-            return hash_js_1.Hash.sha256sha256(w.toBuffer());
+            return hash_1.Hash.sha256sha256(w.toBuffer());
         });
         const spentOutputsMerkle = getMerkleRoot(spentOutputHashes);
         writer.write(spentOutputsMerkle.root);
         const totalInputAmount = spentOutputs.reduce((sum, output) => sum + output.satoshis, 0);
-        writer.writeUInt64LEBN(new bn_js_1.BN(totalInputAmount));
+        writer.writeUInt64LEBN(new bn_1.BN(totalInputAmount));
     }
-    if (baseType === signature_js_1.Signature.SIGHASH_ALL) {
+    if (baseType === signature_1.Signature.SIGHASH_ALL) {
         const totalOutputAmount = transaction.outputs.reduce((sum, output) => sum + output.satoshis, 0);
-        writer.writeUInt64LEBN(new bn_js_1.BN(totalOutputAmount));
+        writer.writeUInt64LEBN(new bn_1.BN(totalOutputAmount));
     }
     writer.writeUInt32LE(transaction.version || 2);
-    if (!(sighashType & signature_js_1.Signature.SIGHASH_ANYONECANPAY)) {
+    if (!(sighashType & signature_1.Signature.SIGHASH_ANYONECANPAY)) {
         const inputHashes = transaction.inputs.map(inp => {
-            const w = new bufferwriter_js_1.BufferWriter();
+            const w = new bufferwriter_1.BufferWriter();
             w.writeReverse(inp.prevTxId);
             w.writeUInt32LE(inp.outputIndex);
             w.writeUInt32LE(inp.sequenceNumber);
-            return hash_js_1.Hash.sha256sha256(w.toBuffer());
+            return hash_1.Hash.sha256sha256(w.toBuffer());
         });
         const inputsMerkle = getMerkleRoot(inputHashes);
         writer.write(inputsMerkle.root);
         writer.writeUInt8(inputsMerkle.height);
     }
-    if (baseType === signature_js_1.Signature.SIGHASH_SINGLE) {
+    if (baseType === signature_1.Signature.SIGHASH_SINGLE) {
         if (inputNumber >= transaction.outputs.length) {
             throw new Error('SIGHASH_SINGLE: no corresponding output for input');
         }
-        const w = new bufferwriter_js_1.BufferWriter();
+        const w = new bufferwriter_1.BufferWriter();
         transaction.outputs[inputNumber].toBufferWriter(w);
-        const outputHash = hash_js_1.Hash.sha256sha256(w.toBuffer());
+        const outputHash = hash_1.Hash.sha256sha256(w.toBuffer());
         writer.write(outputHash);
     }
-    if (baseType === signature_js_1.Signature.SIGHASH_ALL) {
+    if (baseType === signature_1.Signature.SIGHASH_ALL) {
         const outputHashes = transaction.outputs.map(output => {
-            const w = new bufferwriter_js_1.BufferWriter();
+            const w = new bufferwriter_1.BufferWriter();
             output.toBufferWriter(w);
-            return hash_js_1.Hash.sha256sha256(w.toBuffer());
+            return hash_1.Hash.sha256sha256(w.toBuffer());
         });
         const outputsMerkle = getMerkleRoot(outputHashes);
         writer.write(outputsMerkle.root);
         writer.writeUInt8(outputsMerkle.height);
     }
     writer.writeUInt32LE(transaction.nLockTime || 0);
-    return hash_js_1.Hash.sha256sha256(writer.toBuffer());
+    return hash_1.Hash.sha256sha256(writer.toBuffer());
 }
 function sighashForForkId(transaction, sighashType, inputNumber, subscript, satoshisBN) {
     const input = transaction.inputs[inputNumber];
-    preconditions_js_1.Preconditions.checkArgument(satoshisBN instanceof bn_js_1.BN, 'For ForkId=0 signatures, satoshis or complete input must be provided');
-    let hashPrevouts = buffer_js_1.BufferUtil.emptyBuffer(32);
-    let hashSequence = buffer_js_1.BufferUtil.emptyBuffer(32);
-    let hashOutputs = buffer_js_1.BufferUtil.emptyBuffer(32);
-    if (!(sighashType & signature_js_1.Signature.SIGHASH_ANYONECANPAY)) {
+    preconditions_1.Preconditions.checkArgument(satoshisBN instanceof bn_1.BN, 'For ForkId=0 signatures, satoshis or complete input must be provided');
+    let hashPrevouts = buffer_1.BufferUtil.emptyBuffer(32);
+    let hashSequence = buffer_1.BufferUtil.emptyBuffer(32);
+    let hashOutputs = buffer_1.BufferUtil.emptyBuffer(32);
+    if (!(sighashType & signature_1.Signature.SIGHASH_ANYONECANPAY)) {
         hashPrevouts = GetPrevoutHash(transaction);
     }
-    if (!(sighashType & signature_js_1.Signature.SIGHASH_ANYONECANPAY) &&
-        (sighashType & 31) !== signature_js_1.Signature.SIGHASH_SINGLE &&
-        (sighashType & 31) !== signature_js_1.Signature.SIGHASH_NONE) {
+    if (!(sighashType & signature_1.Signature.SIGHASH_ANYONECANPAY) &&
+        (sighashType & 31) !== signature_1.Signature.SIGHASH_SINGLE &&
+        (sighashType & 31) !== signature_1.Signature.SIGHASH_NONE) {
         hashSequence = GetSequenceHash(transaction);
     }
-    if ((sighashType & 31) !== signature_js_1.Signature.SIGHASH_SINGLE &&
-        (sighashType & 31) !== signature_js_1.Signature.SIGHASH_NONE) {
+    if ((sighashType & 31) !== signature_1.Signature.SIGHASH_SINGLE &&
+        (sighashType & 31) !== signature_1.Signature.SIGHASH_NONE) {
         hashOutputs = GetOutputsHash(transaction);
     }
-    else if ((sighashType & 31) === signature_js_1.Signature.SIGHASH_SINGLE &&
+    else if ((sighashType & 31) === signature_1.Signature.SIGHASH_SINGLE &&
         inputNumber < transaction.outputs.length) {
         hashOutputs = GetOutputsHash(transaction, inputNumber);
     }
-    const writer = new bufferwriter_js_1.BufferWriter();
+    const writer = new bufferwriter_1.BufferWriter();
     writer.writeUInt32LE(transaction.version || 2);
     writer.write(hashPrevouts);
     writer.write(hashSequence);
@@ -161,16 +161,16 @@ function sighashForForkId(transaction, sighashType, inputNumber, subscript, sato
     writer.writeUInt32LE(transaction.nLockTime || 0);
     writer.writeUInt32LE(sighashType >>> 0);
     const buf = writer.toBuffer();
-    const hash = hash_js_1.Hash.sha256sha256(buf);
-    return new bufferreader_js_1.BufferReader(hash).read(32);
+    const hash = hash_1.Hash.sha256sha256(buf);
+    return new bufferreader_1.BufferReader(hash).read(32);
 }
 function sighashLegacy(transaction, sighashType, inputNumber, subscript) {
     const input = transaction.inputs[inputNumber];
     function getHash(w) {
         const buf = w.toBuffer();
-        return hash_js_1.Hash.sha256sha256(buf);
+        return hash_1.Hash.sha256sha256(buf);
     }
-    const writer = new bufferwriter_js_1.BufferWriter();
+    const writer = new bufferwriter_1.BufferWriter();
     writer.writeUInt32LE(2);
     writer.writeVarintNum(transaction.inputs.length);
     for (let i = 0; i < transaction.inputs.length; i++) {
@@ -186,13 +186,13 @@ function sighashLegacy(transaction, sighashType, inputNumber, subscript) {
         writer.writeUInt32LENumber(txInput.sequenceNumber);
     }
     writer.writeVarintNum(transaction.outputs.length);
-    if ((sighashType & 31) !== signature_js_1.Signature.SIGHASH_SINGLE &&
-        (sighashType & 31) !== signature_js_1.Signature.SIGHASH_NONE) {
+    if ((sighashType & 31) !== signature_1.Signature.SIGHASH_SINGLE &&
+        (sighashType & 31) !== signature_1.Signature.SIGHASH_NONE) {
         for (const output of transaction.outputs) {
             output.toBufferWriter(writer);
         }
     }
-    else if ((sighashType & 31) === signature_js_1.Signature.SIGHASH_SINGLE &&
+    else if ((sighashType & 31) === signature_1.Signature.SIGHASH_SINGLE &&
         inputNumber < transaction.outputs.length) {
         transaction.outputs[inputNumber].toBufferWriter(writer);
     }
@@ -204,85 +204,85 @@ function sighash(transaction, sighashType, inputNumber, subscript, satoshisBN, f
     if (flags === undefined) {
         flags = DEFAULT_SIGN_FLAGS_CONST;
     }
-    const txcopy = transaction_js_1.Transaction.shallowCopy(transaction);
-    subscript = new script_js_1.Script(subscript);
-    if (flags & interpreter_js_1.Interpreter.SCRIPT_ENABLE_REPLAY_PROTECTION) {
+    const txcopy = transaction_1.Transaction.shallowCopy(transaction);
+    subscript = new script_1.Script(subscript);
+    if (flags & interpreter_1.Interpreter.SCRIPT_ENABLE_REPLAY_PROTECTION) {
         const forkValue = sighashType >> 8;
         const newForkValue = 0xff0000 | (forkValue ^ 0xdead);
         sighashType = (newForkValue << 8) | (sighashType & 0xff);
     }
     const algorithmBits = sighashType & SIGHASH_ALGORITHM_MASK;
-    if (algorithmBits === signature_js_1.Signature.SIGHASH_LOTUS &&
-        flags & interpreter_js_1.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) {
+    if (algorithmBits === signature_1.Signature.SIGHASH_LOTUS &&
+        flags & interpreter_1.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) {
         const spentOutputs = transaction.spentOutputs;
         if (!spentOutputs || spentOutputs.length !== transaction.inputs.length) {
             throw new Error('SIGHASH_LOTUS requires spent outputs for all inputs (ensure all inputs have output information)');
         }
         return sighashForLotus(txcopy, sighashType, inputNumber, spentOutputs);
     }
-    if (algorithmBits === signature_js_1.Signature.SIGHASH_FORKID &&
-        flags & interpreter_js_1.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) {
+    if (algorithmBits === signature_1.Signature.SIGHASH_FORKID &&
+        flags & interpreter_1.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID) {
         return sighashForForkId(txcopy, sighashType, inputNumber, subscript, satoshisBN);
     }
     subscript.removeCodeseparators();
     for (let i = 0; i < txcopy.inputs.length; i++) {
-        txcopy.inputs[i] = new input_js_1.Input({
+        txcopy.inputs[i] = new input_1.Input({
             prevTxId: txcopy.inputs[i].prevTxId,
             outputIndex: txcopy.inputs[i].outputIndex,
             sequenceNumber: txcopy.inputs[i].sequenceNumber,
-            script: (0, script_js_1.empty)(),
+            script: script_1.Script.empty(),
         });
     }
-    txcopy.inputs[inputNumber] = new input_js_1.Input({
+    txcopy.inputs[inputNumber] = new input_1.Input({
         prevTxId: txcopy.inputs[inputNumber].prevTxId,
         outputIndex: txcopy.inputs[inputNumber].outputIndex,
         sequenceNumber: txcopy.inputs[inputNumber].sequenceNumber,
         script: subscript,
     });
-    if ((sighashType & 31) === signature_js_1.Signature.SIGHASH_NONE ||
-        (sighashType & 31) === signature_js_1.Signature.SIGHASH_SINGLE) {
+    if ((sighashType & 31) === signature_1.Signature.SIGHASH_NONE ||
+        (sighashType & 31) === signature_1.Signature.SIGHASH_SINGLE) {
         for (let i = 0; i < txcopy.inputs.length; i++) {
             if (i !== inputNumber) {
                 txcopy.inputs[i].sequenceNumber = 0;
             }
         }
     }
-    if ((sighashType & 31) === signature_js_1.Signature.SIGHASH_NONE) {
+    if ((sighashType & 31) === signature_1.Signature.SIGHASH_NONE) {
         txcopy.outputs = [];
     }
-    else if ((sighashType & 31) === signature_js_1.Signature.SIGHASH_SINGLE) {
+    else if ((sighashType & 31) === signature_1.Signature.SIGHASH_SINGLE) {
         if (inputNumber >= txcopy.outputs.length) {
-            return Buffer.from(SIGHASH_SINGLE_BUG_CONST, 'hex');
+            return buffer_1.BufferUtil.from(SIGHASH_SINGLE_BUG_CONST, 'hex');
         }
         txcopy.outputs.length = inputNumber + 1;
         for (let i = 0; i < inputNumber; i++) {
-            txcopy.outputs[i] = new output_js_1.Output({
-                satoshis: bn_js_1.BN.fromBuffer(Buffer.from(BITS_64_ON_CONST, 'hex')),
-                script: (0, script_js_1.empty)(),
+            txcopy.outputs[i] = new output_1.Output({
+                satoshis: bn_1.BN.fromBuffer(buffer_1.BufferUtil.from(BITS_64_ON_CONST, 'hex')),
+                script: script_1.Script.empty(),
             });
         }
     }
-    if (sighashType & signature_js_1.Signature.SIGHASH_ANYONECANPAY) {
+    if (sighashType & signature_1.Signature.SIGHASH_ANYONECANPAY) {
         txcopy.inputs = [txcopy.inputs[inputNumber]];
     }
-    const buf = new bufferwriter_js_1.BufferWriter()
+    const buf = new bufferwriter_1.BufferWriter()
         .write(txcopy.toBuffer())
         .writeInt32LE(sighashType >>> 0)
         .toBuffer();
-    const hash = hash_js_1.Hash.sha256sha256(buf);
-    return new bufferreader_js_1.BufferReader(hash).readReverse(32);
+    const hash = hash_1.Hash.sha256sha256(buf);
+    return new bufferreader_1.BufferReader(hash).readReverse(32);
 }
 function sign(transaction, privateKey, sighashType, inputIndex, subscript, satoshisBN, flags, signingMethod) {
     const hashbuf = sighash(transaction, sighashType, inputIndex, subscript, satoshisBN, flags);
     signingMethod = signingMethod || 'ecdsa';
     let sig;
     if (signingMethod === 'schnorr') {
-        sig = schnorr_js_1.Schnorr.sign(hashbuf, privateKey, 'big');
+        sig = schnorr_1.Schnorr.sign(hashbuf, privateKey, 'big');
         sig.nhashtype = sighashType;
         return sig;
     }
     else if (signingMethod === 'ecdsa') {
-        sig = ecdsa_js_1.ECDSA.sign(hashbuf, privateKey, 'big');
+        sig = ecdsa_1.ECDSA.sign(hashbuf, privateKey, 'big');
         sig.nhashtype = sighashType;
         return sig;
     }
@@ -291,39 +291,39 @@ function sign(transaction, privateKey, sighashType, inputIndex, subscript, satos
     }
 }
 function verify(transaction, signature, publicKey, inputIndex, subscript, satoshisBN, flags, signingMethod) {
-    preconditions_js_1.Preconditions.checkArgument(transaction !== undefined, 'Transaction is required');
-    preconditions_js_1.Preconditions.checkArgument(signature !== undefined && signature.nhashtype !== undefined, 'Signature with nhashtype is required');
+    preconditions_1.Preconditions.checkArgument(transaction !== undefined, 'Transaction is required');
+    preconditions_1.Preconditions.checkArgument(signature !== undefined && signature.nhashtype !== undefined, 'Signature with nhashtype is required');
     const hashbuf = sighash(transaction, signature.nhashtype, inputIndex, subscript, satoshisBN, flags);
     signingMethod = signingMethod || 'ecdsa';
     if (signingMethod === 'schnorr') {
-        return schnorr_js_1.Schnorr.verify(hashbuf, signature, publicKey, 'big');
+        return schnorr_1.Schnorr.verify(hashbuf, signature, publicKey, 'big');
     }
     else if (signingMethod === 'ecdsa') {
-        return ecdsa_js_1.ECDSA.verify(hashbuf, signature, publicKey, 'big');
+        return ecdsa_1.ECDSA.verify(hashbuf, signature, publicKey, 'big');
     }
     else {
         throw new Error('Invalid signing method. Must be "ecdsa" or "schnorr"');
     }
 }
 function GetPrevoutHash(tx) {
-    const writer = new bufferwriter_js_1.BufferWriter();
+    const writer = new bufferwriter_1.BufferWriter();
     for (const input of tx.inputs) {
         writer.writeReverse(input.prevTxId);
         writer.writeUInt32LE(input.outputIndex);
     }
     const buf = writer.toBuffer();
-    return hash_js_1.Hash.sha256sha256(buf);
+    return hash_1.Hash.sha256sha256(buf);
 }
 function GetSequenceHash(tx) {
-    const writer = new bufferwriter_js_1.BufferWriter();
+    const writer = new bufferwriter_1.BufferWriter();
     for (const input of tx.inputs) {
         writer.writeUInt32LENumber(input.sequenceNumber);
     }
     const buf = writer.toBuffer();
-    return hash_js_1.Hash.sha256sha256(buf);
+    return hash_1.Hash.sha256sha256(buf);
 }
 function GetOutputsHash(tx, n) {
-    const writer = new bufferwriter_js_1.BufferWriter();
+    const writer = new bufferwriter_1.BufferWriter();
     if (n === undefined) {
         for (const output of tx.outputs) {
             output.toBufferWriter(writer);
@@ -333,7 +333,7 @@ function GetOutputsHash(tx, n) {
         tx.outputs[n].toBufferWriter(writer);
     }
     const buf = writer.toBuffer();
-    return hash_js_1.Hash.sha256sha256(buf);
+    return hash_1.Hash.sha256sha256(buf);
 }
 exports.DEFAULT_SIGN_FLAGS = DEFAULT_SIGN_FLAGS_CONST;
 exports.SIGHASH_SINGLE_BUG = SIGHASH_SINGLE_BUG_CONST;