@scure/btc-signer 1.8.1 → 2.0.0

package/transaction.js

@@ -1,40 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transaction = exports.SigHash = exports.SignatureHash = exports.def = exports.Decimal = exports.DEFAULT_SEQUENCE = exports.DEFAULT_LOCKTIME = exports.DEFAULT_VERSION = exports.PRECISION = exports.toVsize = void 0;
-exports.cloneDeep = cloneDeep;
-exports.inputBeforeSign = inputBeforeSign;
-exports.getPrevOut = getPrevOut;
-exports.normalizeInput = normalizeInput;
-exports.getInputType = getInputType;
-exports.PSBTCombine = PSBTCombine;
-exports.bip32Path = bip32Path;
-const base_1 = require("@scure/base");
-const P = require("micro-packed");
-const payment_ts_1 = require("./payment.js");
-const psbt = require("./psbt.js");
-const script_ts_1 = require("./script.js");
-const u = require("./utils.js");
-const utils_ts_1 = require("./utils.js");
+import { hex } from '@scure/base';
+import * as P from 'micro-packed';
+import { Address, OutScript, checkScript, tapLeafHash } from "./payment.js";
+import * as psbt from "./psbt.js";
+import { CompactSizeLen, RawOldTx, RawOutput, RawTx, RawWitness, Script, VarBytes, } from "./script.js";
+import * as u from "./utils.js";
+import { NETWORK, concatBytes, equalBytes, isBytes } from "./utils.js";
 const EMPTY32 = new Uint8Array(32);
 const EMPTY_OUTPUT = {
     amount: 0xffffffffffffffffn,
     script: P.EMPTY,
 };
-const toVsize = (weight) => Math.ceil(weight / 4);
-exports.toVsize = toVsize;
-exports.PRECISION = 8;
-exports.DEFAULT_VERSION = 2;
-exports.DEFAULT_LOCKTIME = 0;
-exports.DEFAULT_SEQUENCE = 4294967295;
-exports.Decimal = P.coders.decimal(exports.PRECISION);
+export const toVsize = (weight) => Math.ceil(weight / 4);
+export const PRECISION = 8;
+export const DEFAULT_VERSION = 2;
+export const DEFAULT_LOCKTIME = 0;
+export const DEFAULT_SEQUENCE = 4294967295;
+export const Decimal = P.coders.decimal(PRECISION);
 // Same as value || def, but doesn't overwrites zero ('0', 0, 0n, etc)
-const def = (value, def) => (value === undefined ? def : value);
-exports.def = def;
-function cloneDeep(obj) {
+export const def = (value, def) => (value === undefined ? def : value);
+export function cloneDeep(obj) {
     if (Array.isArray(obj))
         return obj.map((i) => cloneDeep(i));
     // slice of nodejs Buffer doesn't copy
-    else if ((0, utils_ts_1.isBytes)(obj))
+    else if (isBytes(obj))
         return Uint8Array.from(obj);
     // immutable
     else if (['number', 'bigint', 'boolean', 'string', 'undefined'].includes(typeof obj))
@@ -52,27 +40,26 @@ function cloneDeep(obj) {
  * Internal, exported only for backwards-compat. Use `SigHash` instead.
  * @deprecated
  */
-var SignatureHash;
-(function (SignatureHash) {
-    SignatureHash[SignatureHash["DEFAULT"] = 0] = "DEFAULT";
-    SignatureHash[SignatureHash["ALL"] = 1] = "ALL";
-    SignatureHash[SignatureHash["NONE"] = 2] = "NONE";
-    SignatureHash[SignatureHash["SINGLE"] = 3] = "SINGLE";
-    SignatureHash[SignatureHash["ANYONECANPAY"] = 128] = "ANYONECANPAY";
-})(SignatureHash || (exports.SignatureHash = SignatureHash = {}));
-var SigHash;
-(function (SigHash) {
-    SigHash[SigHash["DEFAULT"] = 0] = "DEFAULT";
-    SigHash[SigHash["ALL"] = 1] = "ALL";
-    SigHash[SigHash["NONE"] = 2] = "NONE";
-    SigHash[SigHash["SINGLE"] = 3] = "SINGLE";
-    SigHash[SigHash["DEFAULT_ANYONECANPAY"] = 128] = "DEFAULT_ANYONECANPAY";
-    SigHash[SigHash["ALL_ANYONECANPAY"] = 129] = "ALL_ANYONECANPAY";
-    SigHash[SigHash["NONE_ANYONECANPAY"] = 130] = "NONE_ANYONECANPAY";
-    SigHash[SigHash["SINGLE_ANYONECANPAY"] = 131] = "SINGLE_ANYONECANPAY";
-})(SigHash || (exports.SigHash = SigHash = {}));
+export const SignatureHash = {
+    DEFAULT: 0,
+    ALL: 1,
+    NONE: 2,
+    SINGLE: 3,
+    ANYONECANPAY: 0x80,
+};
+export const SigHash = {
+    DEFAULT: SignatureHash.DEFAULT,
+    ALL: SignatureHash.ALL,
+    NONE: SignatureHash.NONE,
+    SINGLE: SignatureHash.SINGLE,
+    DEFAULT_ANYONECANPAY: SignatureHash.DEFAULT | SignatureHash.ANYONECANPAY,
+    ALL_ANYONECANPAY: SignatureHash.ALL | SignatureHash.ANYONECANPAY,
+    NONE_ANYONECANPAY: SignatureHash.NONE | SignatureHash.ANYONECANPAY,
+    SINGLE_ANYONECANPAY: SignatureHash.SINGLE | SignatureHash.ANYONECANPAY,
+};
+export const SigHashNames = u.reverseObject(SigHash);
 function getTaprootKeys(privKey, pubKey, internalKey, merkleRoot = P.EMPTY) {
-    if ((0, utils_ts_1.equalBytes)(internalKey, pubKey)) {
+    if (equalBytes(internalKey, pubKey)) {
         privKey = u.taprootTweakPrivKey(privKey, merkleRoot);
         pubKey = u.pubSchnorr(privKey);
     }
@@ -85,14 +72,14 @@ function outputBeforeSign(i) {
     return { script: i.script, amount: i.amount };
 }
 // Force check index/txid/sequence
-function inputBeforeSign(i) {
+export function inputBeforeSign(i) {
     if (i.txid === undefined || i.index === undefined)
         throw new Error('Transaction/input: txid and index required');
     return {
         txid: i.txid,
         index: i.index,
-        sequence: (0, exports.def)(i.sequence, exports.DEFAULT_SEQUENCE),
-        finalScriptSig: (0, exports.def)(i.finalScriptSig, P.EMPTY),
+        sequence: def(i.sequence, DEFAULT_SEQUENCE),
+        finalScriptSig: def(i.finalScriptSig, P.EMPTY),
     };
 }
 function cleanFinalInput(i) {
@@ -105,7 +92,7 @@ function cleanFinalInput(i) {
 // (TxHash, Idx)
 const TxHashIdx = P.struct({ txid: P.bytes(32, true), index: P.U32LE });
 function validateSigHash(s) {
-    if (typeof s !== 'number' || typeof SigHash[s] !== 'string')
+    if (typeof s !== 'number' || typeof SigHashNames[s] !== 'string')
         throw new Error(`Invalid SigHash=${s}`);
     return s;
 }
@@ -123,9 +110,9 @@ function validateOpts(opts) {
     const _opts = {
         ...opts,
         // Defaults
-        version: (0, exports.def)(opts.version, exports.DEFAULT_VERSION),
-        lockTime: (0, exports.def)(opts.lockTime, 0),
-        PSBTVersion: (0, exports.def)(opts.PSBTVersion, 0),
+        version: def(opts.version, DEFAULT_VERSION),
+        lockTime: def(opts.lockTime, 0),
+        PSBTVersion: def(opts.PSBTVersion, 0),
     };
     if (typeof _opts.allowUnknowInput !== 'undefined')
         opts.allowUnknownInputs = _opts.allowUnknowInput;
@@ -181,7 +168,7 @@ function validateInput(i) {
             throw new Error(`validateInput: index(${i.index}) not in nonWitnessUtxo`);
         const prevOut = i.nonWitnessUtxo.outputs[i.index];
         if (i.witnessUtxo &&
-            (!(0, utils_ts_1.equalBytes)(i.witnessUtxo.script, prevOut.script) || i.witnessUtxo.amount !== prevOut.amount))
+            (!equalBytes(i.witnessUtxo.script, prevOut.script) || i.witnessUtxo.amount !== prevOut.amount))
             throw new Error('validateInput: witnessUtxo different from nonWitnessUtxo');
         if (i.txid) {
             const outputs = i.nonWitnessUtxo.outputs;
@@ -195,12 +182,12 @@ function validateInput(i) {
             //   in case user wants to use wrong input by mistake
             // - Worst case: tx will be rejected by nodes. Still better than disallowing user
             //   to spend real input, no matter how broken it looks
-            const tx = Transaction.fromRaw(script_ts_1.RawTx.encode(i.nonWitnessUtxo), {
+            const tx = Transaction.fromRaw(RawTx.encode(i.nonWitnessUtxo), {
                 allowUnknownOutputs: true,
                 disableScriptCheck: true,
                 allowUnknownInputs: true,
             });
-            const txid = base_1.hex.encode(i.txid);
+            const txid = hex.encode(i.txid);
             // PSBTv2 vectors have non-final tx in inputs
             if (tx.isFinal && tx.id !== txid)
                 throw new Error(`nonWitnessUtxo: wrong txid, exp=${txid} got=${tx.id}`);
@@ -209,7 +196,7 @@ function validateInput(i) {
     return i;
 }
 // Normalizes input
-function getPrevOut(input) {
+export function getPrevOut(input) {
     if (input.nonWitnessUtxo) {
         if (input.index === undefined)
             throw new Error('Unknown input index');
@@ -220,20 +207,20 @@ function getPrevOut(input) {
     else
         throw new Error('Cannot find previous output info');
 }
-function normalizeInput(i, cur, allowedFields, disableScriptCheck = false, allowUnknown = false) {
+export function normalizeInput(i, cur, allowedFields, disableScriptCheck = false, allowUnknown = false) {
     let { nonWitnessUtxo, txid } = i;
     // String support for common fields. We usually prefer Uint8Array to avoid errors
     // like hex looking string accidentally passed, however, in case of nonWitnessUtxo
     // it is better to expect string, since constructing this complex object will be
     // difficult for user
     if (typeof nonWitnessUtxo === 'string')
-        nonWitnessUtxo = base_1.hex.decode(nonWitnessUtxo);
-    if ((0, utils_ts_1.isBytes)(nonWitnessUtxo))
-        nonWitnessUtxo = script_ts_1.RawTx.decode(nonWitnessUtxo);
+        nonWitnessUtxo = hex.decode(nonWitnessUtxo);
+    if (isBytes(nonWitnessUtxo))
+        nonWitnessUtxo = RawTx.decode(nonWitnessUtxo);
     if (!('nonWitnessUtxo' in i) && nonWitnessUtxo === undefined)
         nonWitnessUtxo = cur?.nonWitnessUtxo;
     if (typeof txid === 'string')
-        txid = base_1.hex.decode(txid);
+        txid = hex.decode(txid);
     // TODO: if we have nonWitnessUtxo, we can extract txId from here
     if (txid === undefined)
         txid = cur?.txid;
@@ -241,7 +228,7 @@ function normalizeInput(i, cur, allowedFields, disableScriptCheck = false, allow
     if (!('nonWitnessUtxo' in i) && res.nonWitnessUtxo === undefined)
         delete res.nonWitnessUtxo;
     if (res.sequence === undefined)
-        res.sequence = exports.DEFAULT_SEQUENCE;
+        res.sequence = DEFAULT_SEQUENCE;
     if (res.tapMerkleRoot === null)
         delete res.tapMerkleRoot;
     res = psbt.mergeKeyMap(psbt.PSBTInput, res, cur, allowedFields, allowUnknown);
@@ -252,14 +239,14 @@ function normalizeInput(i, cur, allowedFields, disableScriptCheck = false, allow
     else if (res.witnessUtxo)
         prevOut = res.witnessUtxo;
     if (prevOut && !disableScriptCheck)
-        (0, payment_ts_1.checkScript)(prevOut && prevOut.script, res.redeemScript, res.witnessScript);
+        checkScript(prevOut && prevOut.script, res.redeemScript, res.witnessScript);
     return res;
 }
-function getInputType(input, allowLegacyWitnessUtxo = false) {
+export function getInputType(input, allowLegacyWitnessUtxo = false) {
     let txType = 'legacy';
     let defaultSighash = SignatureHash.ALL;
     const prevOut = getPrevOut(input);
-    const first = payment_ts_1.OutScript.decode(prevOut.script);
+    const first = OutScript.decode(prevOut.script);
     let type = first.type;
     let cur = first;
     const stack = [first];
@@ -280,7 +267,7 @@ function getInputType(input, allowLegacyWitnessUtxo = false) {
         if (first.type === 'sh') {
             if (!input.redeemScript)
                 throw new Error('inputType: sh without redeemScript');
-            let child = payment_ts_1.OutScript.decode(input.redeemScript);
+            let child = OutScript.decode(input.redeemScript);
             if (child.type === 'wpkh' || child.type === 'wsh')
                 txType = 'segwit';
             stack.push(child);
@@ -291,7 +278,7 @@ function getInputType(input, allowLegacyWitnessUtxo = false) {
         if (cur.type === 'wsh') {
             if (!input.witnessScript)
                 throw new Error('inputType: wsh without witnessScript');
-            let child = payment_ts_1.OutScript.decode(input.witnessScript);
+            let child = OutScript.decode(input.witnessScript);
             if (child.type === 'wsh')
                 txType = 'segwit';
             stack.push(child);
@@ -301,7 +288,7 @@ function getInputType(input, allowLegacyWitnessUtxo = false) {
         const last = stack[stack.length - 1];
         if (last.type === 'sh' || last.type === 'wsh')
             throw new Error('inputType: sh/wsh cannot be terminal type');
-        const lastScript = payment_ts_1.OutScript.encode(last);
+        const lastScript = OutScript.encode(last);
         const res = {
             type,
             txType,
@@ -316,20 +303,21 @@ function getInputType(input, allowLegacyWitnessUtxo = false) {
         return res;
     }
 }
-class Transaction {
+export class Transaction {
+    global = {};
+    inputs = []; // use getInput()
+    outputs = []; // use getOutput()
+    opts;
     constructor(opts = {}) {
-        this.global = {};
-        this.inputs = []; // use getInput()
-        this.outputs = []; // use getOutput()
         const _opts = (this.opts = validateOpts(opts));
         // Merge with global structure of PSBTv2
-        if (_opts.lockTime !== exports.DEFAULT_LOCKTIME)
+        if (_opts.lockTime !== DEFAULT_LOCKTIME)
             this.global.fallbackLocktime = _opts.lockTime;
         this.global.txVersion = _opts.version;
     }
     // Import
     static fromRaw(raw, opts = {}) {
-        const parsed = script_ts_1.RawTx.decode(raw);
+        const parsed = RawTx.decode(raw);
         const tx = new Transaction({ ...opts, version: parsed.version, lockTime: parsed.lockTime });
         for (const o of parsed.outputs)
             tx.addOutput(o);
@@ -376,7 +364,7 @@ class Transaction {
             ...parsed.global.unsignedTx?.outputs[j],
         }));
         tx.global = { ...parsed.global, txVersion: version }; // just in case proprietary/unknown fields
-        if (lockTime !== exports.DEFAULT_LOCKTIME)
+        if (lockTime !== DEFAULT_LOCKTIME)
             tx.global.fallbackLocktime = lockTime;
         return tx;
     }
@@ -407,7 +395,7 @@ class Transaction {
             - Parsing of PSBTv0 depends on unsignedTx (it looks for input count here)
             - BIP-174 requires old serialization format (without witnesses) inside global, which solves this
             */
-            global.unsignedTx = script_ts_1.RawOldTx.decode(script_ts_1.RawOldTx.encode({
+            global.unsignedTx = RawOldTx.decode(RawOldTx.encode({
                 version: this.version,
                 lockTime: this.lockTime,
                 inputs: this.inputs.map(inputBeforeSign).map((i) => ({
@@ -424,7 +412,7 @@ class Transaction {
             global.txVersion = this.version;
             global.inputCount = this.inputs.length;
             global.outputCount = this.outputs.length;
-            if (global.fallbackLocktime && global.fallbackLocktime === exports.DEFAULT_LOCKTIME)
+            if (global.fallbackLocktime && global.fallbackLocktime === DEFAULT_LOCKTIME)
                 delete global.fallbackLocktime;
         }
         if (this.opts.bip174jsCompat) {
@@ -441,9 +429,9 @@ class Transaction {
     }
     // BIP370 lockTime (https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#determining-lock-time)
     get lockTime() {
-        let height = exports.DEFAULT_LOCKTIME;
+        let height = DEFAULT_LOCKTIME;
         let heightCnt = 0;
-        let time = exports.DEFAULT_LOCKTIME;
+        let time = DEFAULT_LOCKTIME;
         let timeCnt = 0;
         for (const i of this.inputs) {
             if (i.requiredHeightLocktime) {
@@ -457,9 +445,9 @@ class Transaction {
         }
         if (heightCnt && heightCnt >= timeCnt)
             return height;
-        if (time !== exports.DEFAULT_LOCKTIME)
+        if (time !== DEFAULT_LOCKTIME)
             return time;
-        return this.global.fallbackLocktime || exports.DEFAULT_LOCKTIME;
+        return this.global.fallbackLocktime || DEFAULT_LOCKTIME;
     }
     get version() {
         // Should be not possible
@@ -552,25 +540,25 @@ class Transaction {
         let out = 32;
         // Outputs
         const outputs = this.outputs.map(outputBeforeSign);
-        out += 4 * script_ts_1.CompactSizeLen.encode(this.outputs.length).length;
+        out += 4 * CompactSizeLen.encode(this.outputs.length).length;
         for (const o of outputs)
-            out += 32 + 4 * script_ts_1.VarBytes.encode(o.script).length;
+            out += 32 + 4 * VarBytes.encode(o.script).length;
         // Inputs
         if (this.hasWitnesses)
             out += 2;
-        out += 4 * script_ts_1.CompactSizeLen.encode(this.inputs.length).length;
+        out += 4 * CompactSizeLen.encode(this.inputs.length).length;
         for (const i of this.inputs) {
-            out += 160 + 4 * script_ts_1.VarBytes.encode(i.finalScriptSig || P.EMPTY).length;
+            out += 160 + 4 * VarBytes.encode(i.finalScriptSig || P.EMPTY).length;
             if (this.hasWitnesses && i.finalScriptWitness)
-                out += script_ts_1.RawWitness.encode(i.finalScriptWitness).length;
+                out += RawWitness.encode(i.finalScriptWitness).length;
         }
         return out;
     }
     get vsize() {
-        return (0, exports.toVsize)(this.weight);
+        return toVsize(this.weight);
     }
     toBytes(withScriptSig = false, withWitness = false) {
-        return script_ts_1.RawTx.encode({
+        return RawTx.encode({
             version: this.version,
             lockTime: this.lockTime,
             inputs: this.inputs.map(inputBeforeSign).map((i) => ({
@@ -586,17 +574,13 @@ class Transaction {
         return this.toBytes(false, false);
     }
     get hex() {
-        return base_1.hex.encode(this.toBytes(true, this.hasWitnesses));
+        return hex.encode(this.toBytes(true, this.hasWitnesses));
     }
     get hash() {
-        if (!this.isFinal)
-            throw new Error('Transaction is not finalized');
-        return base_1.hex.encode(u.sha256x2(this.toBytes(true)));
+        return hex.encode(u.sha256x2(this.toBytes(true)));
     }
     get id() {
-        if (!this.isFinal)
-            throw new Error('Transaction is not finalized');
-        return base_1.hex.encode(u.sha256x2(this.toBytes(true)).reverse());
+        return hex.encode(u.sha256x2(this.toBytes(true)).reverse());
     }
     // Input stuff
     checkInputIdx(idx) {
@@ -636,11 +620,11 @@ class Transaction {
         this.checkOutputIdx(idx);
         return cloneDeep(this.outputs[idx]);
     }
-    getOutputAddress(idx, network = utils_ts_1.NETWORK) {
+    getOutputAddress(idx, network = NETWORK) {
         const out = this.getOutput(idx);
         if (!out.script)
             return;
-        return (0, payment_ts_1.Address)(network).encode(payment_ts_1.OutScript.decode(out.script));
+        return Address(network).encode(OutScript.decode(out.script));
     }
     get outputsLength() {
         return this.outputs.length;
@@ -652,7 +636,7 @@ class Transaction {
         if (typeof amount !== 'bigint')
             throw new Error(`Wrong amount type, should be of type bigint in sats, but got ${amount} of type ${typeof amount}`);
         if (typeof script === 'string')
-            script = base_1.hex.decode(script);
+            script = hex.decode(script);
         if (script === undefined)
             script = cur?.script;
         let res = { ...cur, ...o, amount, script };
@@ -662,11 +646,11 @@ class Transaction {
         psbt.PSBTOutputCoder.encode(res);
         if (res.script &&
             !this.opts.allowUnknownOutputs &&
-            payment_ts_1.OutScript.decode(res.script).type === 'unknown') {
+            OutScript.decode(res.script).type === 'unknown') {
             throw new Error('Transaction/output: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownOutputs=true, if you sure');
         }
         if (!this.opts.disableScriptCheck)
-            (0, payment_ts_1.checkScript)(res.script, res.redeemScript, res.witnessScript);
+            checkScript(res.script, res.redeemScript, res.witnessScript);
         return res;
     }
     addOutput(o, _ignoreSignStatus = false) {
@@ -685,8 +669,8 @@ class Transaction {
         }
         this.outputs[idx] = this.normalizeOutput(output, this.outputs[idx], allowedFields);
     }
-    addOutputAddress(address, amount, network = utils_ts_1.NETWORK) {
-        return this.addOutput({ script: payment_ts_1.OutScript.encode((0, payment_ts_1.Address)(network).decode(address)), amount });
+    addOutputAddress(address, amount, network = NETWORK) {
+        return this.addOutput({ script: OutScript.encode(Address(network).decode(address)), amount });
     }
     // Utils
     get fee() {
@@ -712,7 +696,7 @@ class Transaction {
             throw new Error(`Invalid input idx=${idx}`);
         if ((isSingle && idx >= this.outputs.length) || idx >= this.inputs.length)
             return P.U256BE.encode(1n);
-        prevOutScript = script_ts_1.Script.encode(script_ts_1.Script.decode(prevOutScript).filter((i) => i !== 'CODESEPARATOR'));
+        prevOutScript = Script.encode(Script.decode(prevOutScript).filter((i) => i !== 'CODESEPARATOR'));
         let inputs = this.inputs
             .map(inputBeforeSign)
             .map((input, inputIdx) => ({
@@ -733,7 +717,7 @@ class Transaction {
         else if (isSingle) {
             outputs = outputs.slice(0, idx).fill(EMPTY_OUTPUT).concat([outputs[idx]]);
         }
-        const tmpTx = script_ts_1.RawTx.encode({
+        const tmpTx = RawTx.encode({
             lockTime: this.lockTime,
             version: this.version,
             segwitFlag: false,
@@ -754,12 +738,12 @@ class Transaction {
         if (!isAny && !isSingle && !isNone)
             sequenceHash = u.sha256x2(...inputs.map((i) => P.U32LE.encode(i.sequence)));
         if (!isSingle && !isNone) {
-            outputHash = u.sha256x2(...outputs.map(script_ts_1.RawOutput.encode));
+            outputHash = u.sha256x2(...outputs.map(RawOutput.encode));
         }
         else if (isSingle && idx < outputs.length)
-            outputHash = u.sha256x2(script_ts_1.RawOutput.encode(outputs[idx]));
+            outputHash = u.sha256x2(RawOutput.encode(outputs[idx]));
         const input = inputs[idx];
-        return u.sha256x2(P.I32LE.encode(this.version), inputHash, sequenceHash, P.bytes(32, true).encode(input.txid), P.U32LE.encode(input.index), script_ts_1.VarBytes.encode(prevOutScript), P.U64LE.encode(amount), P.U32LE.encode(input.sequence), outputHash, P.U32LE.encode(this.lockTime), P.U32LE.encode(hashType));
+        return u.sha256x2(P.I32LE.encode(this.version), inputHash, sequenceHash, P.bytes(32, true).encode(input.txid), P.U32LE.encode(input.index), VarBytes.encode(prevOutScript), P.U64LE.encode(amount), P.U32LE.encode(input.sequence), outputHash, P.U32LE.encode(this.lockTime), P.U32LE.encode(hashType));
     }
     preimageWitnessV1(idx, prevOutScript, hashType, amount, codeSeparator = -1, leafScript, leafVer = 0xc0, annex) {
         if (!Array.isArray(amount) || this.inputs.length !== amount.length)
@@ -780,27 +764,27 @@ class Transaction {
             out.push(...[
                 inputs.map(TxHashIdx.encode),
                 amount.map(P.U64LE.encode),
-                prevOutScript.map(script_ts_1.VarBytes.encode),
+                prevOutScript.map(VarBytes.encode),
                 inputs.map((i) => P.U32LE.encode(i.sequence)),
-            ].map((i) => u.sha256((0, utils_ts_1.concatBytes)(...i))));
+            ].map((i) => u.sha256(concatBytes(...i))));
         }
         if (outType === SignatureHash.ALL) {
-            out.push(u.sha256((0, utils_ts_1.concatBytes)(...outputs.map(script_ts_1.RawOutput.encode))));
+            out.push(u.sha256(concatBytes(...outputs.map(RawOutput.encode))));
         }
         const spendType = (annex ? 1 : 0) | (leafScript ? 2 : 0);
         out.push(new Uint8Array([spendType]));
         if (inType === SignatureHash.ANYONECANPAY) {
             const inp = inputs[idx];
-            out.push(TxHashIdx.encode(inp), P.U64LE.encode(amount[idx]), script_ts_1.VarBytes.encode(prevOutScript[idx]), P.U32LE.encode(inp.sequence));
+            out.push(TxHashIdx.encode(inp), P.U64LE.encode(amount[idx]), VarBytes.encode(prevOutScript[idx]), P.U32LE.encode(inp.sequence));
         }
         else
             out.push(P.U32LE.encode(idx));
         if (spendType & 1)
-            out.push(u.sha256(script_ts_1.VarBytes.encode(annex || P.EMPTY)));
+            out.push(u.sha256(VarBytes.encode(annex || P.EMPTY)));
         if (outType === SignatureHash.SINGLE)
-            out.push(idx < outputs.length ? u.sha256(script_ts_1.RawOutput.encode(outputs[idx])) : EMPTY32);
+            out.push(idx < outputs.length ? u.sha256(RawOutput.encode(outputs[idx])) : EMPTY32);
         if (leafScript)
-            out.push((0, payment_ts_1.tapLeafHash)(leafScript, leafVer), P.U8.encode(0), P.I32LE.encode(codeSeparator));
+            out.push(tapLeafHash(leafScript, leafVer), P.U8.encode(0), P.I32LE.encode(codeSeparator));
         return u.tagSchnorr('TapSighash', ...out);
     }
     // Signer can be privateKey OR instance of bip32 HD stuff
@@ -809,7 +793,7 @@ class Transaction {
         const input = this.inputs[idx];
         const inputType = getInputType(input, this.opts.allowLegacyWitnessUtxo);
         // Handle BIP32 HDKey
-        if (!(0, utils_ts_1.isBytes)(privateKey)) {
+        if (!isBytes(privateKey)) {
             if (!input.bip32Derivation || !input.bip32Derivation.length)
                 throw new Error('bip32Derivation: empty');
             const signers = input.bip32Derivation
@@ -818,7 +802,7 @@ class Transaction {
                 let s = privateKey;
                 for (const i of path)
                     s = s.deriveChild(i);
-                if (!(0, utils_ts_1.equalBytes)(s.publicKey, pubKey))
+                if (!equalBytes(s.publicKey, pubKey))
                     throw new Error('bip32Derivation: wrong pubKey');
                 if (!s.privateKey)
                     throw new Error('bip32Derivation: no privateKey');
@@ -867,9 +851,9 @@ class Transaction {
                 // priv key to be provided
                 const { pubKey, privKey } = getTaprootKeys(privateKey, schnorrPub, input.tapInternalKey, merkleRoot);
                 const [taprootPubKey, _] = u.taprootTweakPubkey(input.tapInternalKey, merkleRoot);
-                if ((0, utils_ts_1.equalBytes)(taprootPubKey, pubKey)) {
+                if (equalBytes(taprootPubKey, pubKey)) {
                     const hash = this.preimageWitnessV1(idx, prevOutScript, sighash, amount);
-                    const sig = (0, utils_ts_1.concatBytes)(u.signSchnorr(hash, privKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);
+                    const sig = concatBytes(u.signSchnorr(hash, privKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);
                     this.updateInput(idx, { tapKeySig: sig }, true);
                     signed = true;
                 }
@@ -878,16 +862,16 @@ class Transaction {
                 input.tapScriptSig = input.tapScriptSig || [];
                 for (const [_, _script] of input.tapLeafScript) {
                     const script = _script.subarray(0, -1);
-                    const scriptDecoded = script_ts_1.Script.decode(script);
+                    const scriptDecoded = Script.decode(script);
                     const ver = _script[_script.length - 1];
-                    const hash = (0, payment_ts_1.tapLeafHash)(script, ver);
+                    const hash = tapLeafHash(script, ver);
                     // NOTE: no need to tweak internal key here, since we don't support nested p2tr
-                    const pos = scriptDecoded.findIndex((i) => (0, utils_ts_1.isBytes)(i) && (0, utils_ts_1.equalBytes)(i, schnorrPub));
+                    const pos = scriptDecoded.findIndex((i) => isBytes(i) && equalBytes(i, schnorrPub));
                     // Skip if there is no public key in tapLeafScript
                     if (pos === -1)
                         continue;
                     const msg = this.preimageWitnessV1(idx, prevOutScript, sighash, amount, undefined, script, ver);
-                    const sig = (0, utils_ts_1.concatBytes)(u.signSchnorr(msg, privateKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);
+                    const sig = concatBytes(u.signSchnorr(msg, privateKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : P.EMPTY);
                     this.updateInput(idx, { tapScriptSig: [[{ pubKey: schnorrPub, leafHash: hash }, sig]] }, true);
                     signed = true;
                 }
@@ -903,8 +887,8 @@ class Transaction {
             // Check if script has public key or its has inside
             let hasPubkey = false;
             const pubKeyHash = u.hash160(pubKey);
-            for (const i of script_ts_1.Script.decode(inputType.lastScript)) {
-                if ((0, utils_ts_1.isBytes)(i) && ((0, utils_ts_1.equalBytes)(i, pubKey) || (0, utils_ts_1.equalBytes)(i, pubKeyHash)))
+            for (const i of Script.decode(inputType.lastScript)) {
+                if (isBytes(i) && (equalBytes(i, pubKey) || equalBytes(i, pubKeyHash)))
                     hasPubkey = true;
             }
             if (!hasPubkey)
@@ -917,14 +901,14 @@ class Transaction {
                 let script = inputType.lastScript;
                 // If wpkh OR sh-wpkh, wsh-wpkh is impossible, so looks ok
                 if (inputType.last.type === 'wpkh')
-                    script = payment_ts_1.OutScript.encode({ type: 'pkh', hash: inputType.last.hash });
+                    script = OutScript.encode({ type: 'pkh', hash: inputType.last.hash });
                 hash = this.preimageWitnessV0(idx, script, sighash, prevOut.amount);
             }
             else
                 throw new Error(`Transaction/sign: unknown tx type: ${inputType.txType}`);
             const sig = u.signECDSA(hash, privateKey, this.opts.lowR);
             this.updateInput(idx, {
-                partialSig: [[pubKey, (0, utils_ts_1.concatBytes)(sig, new Uint8Array([sighash]))]],
+                partialSig: [[pubKey, concatBytes(sig, new Uint8Array([sighash]))]],
             }, true);
         }
         return true;
@@ -967,16 +951,16 @@ class Transaction {
                     // Last byte is version
                     const script = _script.slice(0, -1);
                     const ver = _script[_script.length - 1];
-                    const outScript = payment_ts_1.OutScript.decode(script);
-                    const hash = (0, payment_ts_1.tapLeafHash)(script, ver);
-                    const scriptSig = input.tapScriptSig.filter((i) => (0, utils_ts_1.equalBytes)(i[0].leafHash, hash));
+                    const outScript = OutScript.decode(script);
+                    const hash = tapLeafHash(script, ver);
+                    const scriptSig = input.tapScriptSig.filter((i) => equalBytes(i[0].leafHash, hash));
                     let signatures = [];
                     if (outScript.type === 'tr_ms') {
                         const m = outScript.m;
                         const pubkeys = outScript.pubkeys;
                         let added = 0;
                         for (const pub of pubkeys) {
-                            const sigIdx = scriptSig.findIndex((i) => (0, utils_ts_1.equalBytes)(i[0].pubKey, pub));
+                            const sigIdx = scriptSig.findIndex((i) => equalBytes(i[0].pubKey, pub));
                             // Should have exact amount of signatures (more -- will fail)
                             if (added === m || sigIdx === -1) {
                                 signatures.push(P.EMPTY);
@@ -991,7 +975,7 @@ class Transaction {
                     }
                     else if (outScript.type === 'tr_ns') {
                         for (const pub of outScript.pubkeys) {
-                            const sigIdx = scriptSig.findIndex((i) => (0, utils_ts_1.equalBytes)(i[0].pubKey, pub));
+                            const sigIdx = scriptSig.findIndex((i) => equalBytes(i[0].pubKey, pub));
                             if (sigIdx === -1)
                                 continue;
                             signatures.push(scriptSig[sigIdx][1]);
@@ -1001,10 +985,10 @@ class Transaction {
                     }
                     else if (outScript.type === 'unknown' && this.opts.allowUnknownInputs) {
                         // Trying our best to sign what we can
-                        const scriptDecoded = script_ts_1.Script.decode(script);
+                        const scriptDecoded = Script.decode(script);
                         signatures = scriptSig
                             .map(([{ pubKey }, signature]) => {
-                            const pos = scriptDecoded.findIndex((i) => (0, utils_ts_1.isBytes)(i) && (0, utils_ts_1.equalBytes)(i, pubKey));
+                            const pos = scriptDecoded.findIndex((i) => isBytes(i) && equalBytes(i, pubKey));
                             if (pos === -1)
                                 throw new Error('finalize/taproot: cannot find position of pubkey in script');
                             return { signature, pos };
@@ -1021,7 +1005,7 @@ class Transaction {
                             for (const c of custom) {
                                 if (!c.finalizeTaproot)
                                     continue;
-                                const scriptDecoded = script_ts_1.Script.decode(script);
+                                const scriptDecoded = Script.decode(script);
                                 const csEncoded = c.encode(scriptDecoded);
                                 if (csEncoded === undefined)
                                     continue;
@@ -1063,7 +1047,7 @@ class Transaction {
             let signatures = [];
             // partial: [pubkey, sign]
             for (const pub of pubkeys) {
-                const sign = input.partialSig.find((s) => (0, utils_ts_1.equalBytes)(pub, s[0]));
+                const sign = input.partialSig.find((s) => equalBytes(pub, s[0]));
                 if (!sign)
                     continue;
                 signatures.push(sign[1]);
@@ -1072,13 +1056,13 @@ class Transaction {
             if (signatures.length !== m) {
                 throw new Error(`Multisig: wrong signatures count, m=${m} n=${pubkeys.length} signatures=${signatures.length}`);
             }
-            inputScript = script_ts_1.Script.encode([0, ...signatures]);
+            inputScript = Script.encode([0, ...signatures]);
         }
         else if (inputType.last.type === 'pk') {
-            inputScript = script_ts_1.Script.encode([input.partialSig[0][1]]);
+            inputScript = Script.encode([input.partialSig[0][1]]);
         }
         else if (inputType.last.type === 'pkh') {
-            inputScript = script_ts_1.Script.encode([input.partialSig[0][1], input.partialSig[0][0]]);
+            inputScript = Script.encode([input.partialSig[0][1], input.partialSig[0][0]]);
         }
         else if (inputType.last.type === 'wpkh') {
             inputScript = P.EMPTY;
@@ -1091,10 +1075,10 @@ class Transaction {
         if (inputType.type.includes('wsh-')) {
             // P2WSH
             if (inputScript.length && inputType.lastScript.length) {
-                witness = script_ts_1.Script.decode(inputScript).map((i) => {
+                witness = Script.decode(inputScript).map((i) => {
                     if (i === 0)
                         return P.EMPTY;
-                    if ((0, utils_ts_1.isBytes)(i))
+                    if (isBytes(i))
                         return i;
                     throw new Error(`Wrong witness op=${i}`);
                 });
@@ -1104,10 +1088,10 @@ class Transaction {
         if (inputType.txType === 'segwit')
             finalScriptWitness = witness;
         if (inputType.type.startsWith('sh-wsh-')) {
-            finalScriptSig = script_ts_1.Script.encode([script_ts_1.Script.encode([0, u.sha256(inputType.lastScript)])]);
+            finalScriptSig = Script.encode([Script.encode([0, u.sha256(inputType.lastScript)])]);
         }
         else if (inputType.type.startsWith('sh-')) {
-            finalScriptSig = script_ts_1.Script.encode([...script_ts_1.Script.decode(inputScript), inputType.lastScript]);
+            finalScriptSig = Script.encode([...Script.decode(inputScript), inputType.lastScript]);
         }
         else if (inputType.type.startsWith('wsh-')) {
         }
@@ -1145,11 +1129,11 @@ class Transaction {
                 throw new Error(`Transaction/combine: different ${k} length this=${this[k].length} other=${other[k].length}`);
             }
         }
-        const thisUnsigned = this.global.unsignedTx ? script_ts_1.RawOldTx.encode(this.global.unsignedTx) : P.EMPTY;
+        const thisUnsigned = this.global.unsignedTx ? RawOldTx.encode(this.global.unsignedTx) : P.EMPTY;
         const otherUnsigned = other.global.unsignedTx
-            ? script_ts_1.RawOldTx.encode(other.global.unsignedTx)
+            ? RawOldTx.encode(other.global.unsignedTx)
             : P.EMPTY;
-        if (!(0, utils_ts_1.equalBytes)(thisUnsigned, otherUnsigned))
+        if (!equalBytes(thisUnsigned, otherUnsigned))
             throw new Error(`Transaction/combine: different unsigned tx`);
         this.global = psbt.mergeKeyMap(psbt.PSBTGlobal, this.global, other.global, undefined, this.opts.allowUnknown);
         for (let i = 0; i < this.inputs.length; i++)
@@ -1163,8 +1147,7 @@ class Transaction {
         return Transaction.fromPSBT(this.toPSBT(this.opts.PSBTVersion), this.opts);
     }
 }
-exports.Transaction = Transaction;
-function PSBTCombine(psbts) {
+export function PSBTCombine(psbts) {
     if (!psbts || !Array.isArray(psbts) || !psbts.length)
         throw new Error('PSBTCombine: wrong PSBT list');
     const tx = Transaction.fromPSBT(psbts[0]);
@@ -1174,7 +1157,7 @@ function PSBTCombine(psbts) {
 }
 // Copy-pasted from bip32 derive, maybe do something like 'bip32.parsePath'?
 const HARDENED_OFFSET = 0x80000000;
-function bip32Path(path) {
+export function bip32Path(path) {
     const out = [];
     if (!/^[mM]'?/.test(path))
         throw new Error('Path must start with "m" or "M"');