@scure/btc-signer 1.3.2 → 1.4.0

package/src/utxo.ts

@@ -268,7 +268,10 @@ export type EstimatorOpts = TxOpts & {
   bip69?: boolean; // https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki
   network?: typeof NETWORK;
   dust?: number; // how much vbytes considered dust?
+  dustRelayFeeRate?: bigint; // fee per dust byte (DUST_RELAY_TX_FEE)
   createTx?: boolean; // Create tx inside selection
+  requiredInputs?: psbt.TransactionInputUpdate[]; // these inputs always will be used
+  allowSameUtxo?: boolean; // allow using UTXO multiple times (for test purposes)
 };
 
 function getScript(o: Output, opts: TxOpts = {}, network = NETWORK) {
@@ -282,7 +285,12 @@ function getScript(o: Output, opts: TxOpts = {}, network = NETWORK) {
     script = OutScript.encode(Address(network).decode(o.address));
   }
   if (!script) throw new Error('Estimator: wrong output script');
-  if (typeof o.amount !== 'bigint') throw new Error(`Estimator: wrong output amount=${o.amount}`);
+  if (typeof o.amount !== 'bigint')
+    throw new Error(
+      `Estimator: wrong output amount=${
+        o.amount
+      }, should be of type bigint but got ${typeof o.amount}.`
+    );
   if (script && !opts.allowUnknownOutputs && OutScript.decode(script).type === 'unknown') {
     throw new Error(
       'Estimator: unknown output script type, there is a chance that input is unspendable. Pass allowUnknownOutputs=true, if you sure'
@@ -310,6 +318,7 @@ export class _Estimator {
   private baseWeight: number;
   private changeWeight: number;
   private amount: bigint;
+  private requiredIndices: number[] = [];
   private normalizedInputs: {
     inputType: ReturnType<typeof getInputType>;
     normalized: ReturnType<typeof normalizeInput>;
@@ -317,24 +326,51 @@ export class _Estimator {
     value: bigint;
     estimate: { weight: number; hasWitnesses: boolean };
   }[];
-  // https://github.com/bitcoin/bitcoin/blob/f90603ac6d24f5263649675d51233f1fce8b2ecd/src/policy/policy.cpp#L44
-  // 32 + 4 + 1 + 107 + 4
   // Dust used in accumExact + change address algo
   // - change address: can be smaller for segwit
   // - accumExact: ???
-  private dust = 148n; // compat with coinselect
-
+  private dust: bigint; // total dust limit (3||opts.dustRelayFeeRate * 182||opts.dust). Default: 546
   constructor(
-    private inputs: psbt.TransactionInputUpdate[],
+    inputs: psbt.TransactionInputUpdate[],
     private outputs: Output[],
     private opts: EstimatorOpts
   ) {
     if (typeof opts.feePerByte !== 'bigint')
-      throw new Error(`Estimator: wrong feePerByte=${opts.feePerByte}`);
-    if (opts.dust) {
-      if (typeof opts.dust !== 'bigint') throw new Error(`Estimator: wrong dust=${opts.dust}`);
-      this.dust = opts.dust;
+      throw new Error(
+        `Estimator: wrong feePerByte=${
+          opts.feePerByte
+        }, should be of type bigint but got ${typeof opts.feePerByte}.`
+      );
+    // Dust stuff
+    // TODO: think about this more:
+    // - current dust filters tx which cannot be relayed by core
+    // - but actual dust meaning is 'can be this amount spent?'
+    // - dust contains full tx size. but we can use other inputs to pay for outputDust (and parially inputsDust)?
+    // - not sure if we can spent anything with feePerByte: 3. It will be relayed, but will it be mined?
+    // - for now it works exactly as bitcoin-core. But will create change/outputs which cannot be spent (reasonable).
+    // Number of bytes needed to create and spend a UTXO.
+    // https://github.com/bitcoin/bitcoin/blob/27a770b34b8f1dbb84760f442edb3e23a0c2420b/src/policy/policy.cpp#L28-L41
+    const inputsDust = 32 + 4 + 1 + 107 + 4; // NOTE: can be smaller for segwit tx?
+    const outputDust = 34; // NOTE: 'nSize = GetSerializeSize(txout)'
+    const dustBytes = opts.dust === undefined ? BigInt(inputsDust + outputDust) : opts.dust;
+    if (typeof dustBytes !== 'bigint') {
+      throw new Error(
+        `Estimator: wrong dust=${opts.dust}, should be of type bigint but got ${typeof opts.dust}.`
+      );
     }
+    // 3 sat/vb is the default minimum fee rate used to calculate dust thresholds by bitcoin core.
+    // 3000 sat/kvb -> 3 sat/vb.
+    // https://github.com/bitcoin/bitcoin/blob/27a770b34b8f1dbb84760f442edb3e23a0c2420b/src/policy/policy.h#L55
+    const dustFee = opts.dustRelayFeeRate === undefined ? 3n : opts.dustRelayFeeRate;
+    if (typeof dustFee !== 'bigint') {
+      throw new Error(
+        `Estimator: wrong dustRelayFeeRate=${opts.dustRelayFeeRate}, should be of type bigint but got ${typeof opts.dustRelayFeeRate}.`
+      );
+    }
+    // Dust uses feePerbyte by default, but we allow separate dust fee if needed
+    this.dust = dustBytes * dustFee;
+    if (opts.requiredInputs !== undefined && !Array.isArray(opts.requiredInputs))
+      throw new Error(`Estimator: wrong required inputs=${opts.requiredInputs}`);
     const network = opts.network || NETWORK;
     let amount = 0n;
     // Base weight: tx with outputs, no inputs
@@ -356,9 +392,19 @@ export class _Estimator {
     this.baseWeight = baseWeight;
     this.changeWeight = changeWeight;
     this.amount = amount;
-    this.normalizedInputs = this.inputs.map((i) => {
+    const allInputs = Array.from(inputs);
+    if (opts.requiredInputs) {
+      for (let i = 0; i < opts.requiredInputs.length; i++)
+        this.requiredIndices.push(allInputs.push(opts.requiredInputs[i]) - 1);
+    }
+    const inputKeys = new Set();
+    this.normalizedInputs = allInputs.map((i) => {
       const normalized = normalizeInput(i, undefined, undefined, opts.disableScriptCheck);
       inputBeforeSign(normalized); // check fields
+      const key = `${hex.encode(normalized.txid!)}:${normalized.index}`;
+      if (!opts.allowSameUtxo && inputKeys.has(key))
+        throw new Error(`Estimator: same input passed multiple times: ${key}`);
+      inputKeys.add(key);
       const inputType = getInputType(normalized, opts.allowLegacyWitnessUtxo);
       const prev = getPrevOut(normalized);
       const estimate = estimateInput(inputType, normalized, this.opts);
@@ -367,7 +413,7 @@ export class _Estimator {
     });
   }
   private checkInputIdx(idx: number) {
-    if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.inputs.length)
+    if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.normalizedInputs.length)
       throw new Error(`Wrong input index=${idx}`);
     return idx;
   }
@@ -397,7 +443,7 @@ export class _Estimator {
 
   // Sort by value instead of amount
   get biggest() {
-    return this.inputs
+    return this.normalizedInputs
       .map((_i, j) => j)
       .sort((a, b) => _cmpBig(this.normalizedInputs[b].value, this.normalizedInputs[a].value));
   }
@@ -408,7 +454,7 @@ export class _Estimator {
   // Otherwise, we have no way to know which tx is oldest
   // Explorers usually give UTXO in this order.
   get oldest() {
-    return this.inputs.map((_i, j) => j);
+    return this.normalizedInputs.map((_i, j) => j);
   }
   get newest() {
     return this.oldest.reverse();
@@ -417,7 +463,6 @@ export class _Estimator {
   // exact(biggest) will select one big utxo which is closer to targetValue+dust, if possible.
   // If not, it will accumulate largest utxo until value is close to targetValue+dust.
   accumulate(indices: number[], exact = false, skipNegative = true, all = false) {
-    const { feePerByte } = this.opts;
     // TODO: how to handle change addresses?
     // - cost of input
     // - cost of change output (if input requires change)
@@ -433,6 +478,22 @@ export class _Estimator {
     const targetAmount = this.amount;
     const res = [];
     let fee;
+    for (const idx of this.requiredIndices) {
+      this.checkInputIdx(idx);
+      const { estimate, amount } = this.normalizedInputs[idx];
+      let newWeight = weight + estimate.weight;
+      if (!hasWitnesses && estimate.hasWitnesses) newWeight += 2; // enable witness if needed
+      const totalWeight = newWeight + 4 * CompactSizeLen.encode(num).length; // number of outputs can change weight
+      fee = this.getSatoshi(totalWeight);
+      weight = newWeight;
+      if (estimate.hasWitnesses) hasWitnesses = true;
+      num++;
+      inputsAmount += amount;
+      res.push(idx);
+      // inputsAmount is enough to cover cost of tx
+      if (!all && targetAmount + fee <= inputsAmount)
+        return { indices: res, fee, weight: totalWeight, total: inputsAmount };
+    }
     for (const idx of indices) {
       this.checkInputIdx(idx);
       const { estimate, amount, value } = this.normalizedInputs[idx];
@@ -441,11 +502,7 @@ export class _Estimator {
       const totalWeight = newWeight + 4 * CompactSizeLen.encode(num).length; // number of outputs can change weight
       fee = this.getSatoshi(totalWeight);
       // Best case scenario exact(biggest) -> we find biggest output, less than target+threshold
-      if (exact) {
-        const dust = this.dust * feePerByte;
-        // skip if added value is bigger than dust
-        if (amount + inputsAmount > targetAmount + fee + dust) continue;
-      }
+      if (exact && amount + inputsAmount > targetAmount + fee + this.dust) continue; // skip if added value is bigger than dust
       // Negative: cost of using input is more than value provided (negative)
       // By default 'blackjack' mode in coinselect doesn't use that, which means
       // it will use negative output if sorted by 'smallest'
@@ -456,7 +513,7 @@ export class _Estimator {
       inputsAmount += amount;
       res.push(idx);
       // inputsAmount is enough to cover cost of tx
-      if (!all && targetAmount + fee < inputsAmount)
+      if (!all && targetAmount + fee <= inputsAmount)
         return { indices: res, fee, weight: totalWeight, total: inputsAmount };
     }
     if (all) {
@@ -477,7 +534,7 @@ export class _Estimator {
   private select(strategy: SelectionStrategy) {
     if (strategy === 'all') {
       return this.accumulate(
-        this.inputs.map((_, j) => j),
+        this.normalizedInputs.map((_, j) => j),
         false,
         true,
         true
@@ -531,7 +588,7 @@ export class _Estimator {
       outputs = this.sortOutputs(outputs).map((i) => outputs[i]);
     }
     const res = {
-      inputs: inputs.map((i) => this.inputs[i]),
+      inputs: inputs.map((i) => this.normalizedInputs[i].normalized),
       outputs,
       fee,
       weight: this.opts.alwaysChange ? s.weight : changeWeight,

package/transaction.d.ts

@@ -0,0 +1,229 @@
+import * as P from 'micro-packed';
+import { CustomScript } from './payment.js';
+import * as psbt from './psbt.js';
+import { Bytes } from './utils.js';
+interface HDKey {
+    publicKey: Bytes;
+    privateKey: Bytes;
+    fingerprint: number;
+    derive(path: string): HDKey;
+    deriveChild(index: number): HDKey;
+    sign(hash: Bytes): Bytes;
+}
+export type Signer = Bytes | HDKey;
+export declare const PRECISION = 8;
+export declare const DEFAULT_VERSION = 2;
+export declare const DEFAULT_LOCKTIME = 0;
+export declare const DEFAULT_SEQUENCE = 4294967295;
+export declare const Decimal: {
+    encode: (from: bigint) => string;
+    decode: (to: string) => bigint;
+};
+export declare const def: <T>(value: T | undefined, def: T) => T;
+export declare function cloneDeep<T>(obj: T): T;
+export type TxOpts = {
+    version?: number;
+    lockTime?: number;
+    PSBTVersion?: number;
+    /** @deprecated Use `allowUnknownOutputs` */
+    allowUnknowOutput?: boolean;
+    allowUnknownOutputs?: boolean;
+    /** @deprecated Use `allowUnknownInputs` */
+    allowUnknowInput?: boolean;
+    allowUnknownInputs?: boolean;
+    disableScriptCheck?: boolean;
+    bip174jsCompat?: boolean;
+    allowLegacyWitnessUtxo?: boolean;
+    lowR?: boolean;
+    customScripts?: CustomScript[];
+};
+/**
+ * Internal, exported only for backwards-compat. Use `SigHash` instead.
+ * @deprecated
+ */
+export declare enum SignatureHash {
+    DEFAULT = 0,
+    ALL = 1,
+    NONE = 2,
+    SINGLE = 3,
+    ANYONECANPAY = 128
+}
+export declare enum SigHash {
+    DEFAULT = 0,
+    ALL = 1,
+    NONE = 2,
+    SINGLE = 3,
+    DEFAULT_ANYONECANPAY = 128,
+    ALL_ANYONECANPAY = 129,
+    NONE_ANYONECANPAY = 130,
+    SINGLE_ANYONECANPAY = 131
+}
+export type TransactionInputRequired = {
+    txid: Bytes;
+    index: number;
+    sequence: number;
+    finalScriptSig: Bytes;
+};
+export declare function inputBeforeSign(i: psbt.TransactionInput): TransactionInputRequired;
+declare function validateOpts(opts: TxOpts): Readonly<{
+    version: number;
+    lockTime: number;
+    PSBTVersion: number;
+    /** @deprecated Use `allowUnknownOutputs` */
+    allowUnknowOutput?: boolean;
+    allowUnknownOutputs?: boolean;
+    /** @deprecated Use `allowUnknownInputs` */
+    allowUnknowInput?: boolean;
+    allowUnknownInputs?: boolean;
+    disableScriptCheck?: boolean;
+    bip174jsCompat?: boolean;
+    allowLegacyWitnessUtxo?: boolean;
+    lowR?: boolean;
+    customScripts?: CustomScript[];
+}>;
+export declare class Transaction {
+    private global;
+    private inputs;
+    private outputs;
+    readonly opts: ReturnType<typeof validateOpts>;
+    constructor(opts?: TxOpts);
+    static fromRaw(raw: Bytes, opts?: TxOpts): Transaction;
+    static fromPSBT(psbt_: Bytes, opts?: TxOpts): Transaction;
+    toPSBT(PSBTVersion?: number): Uint8Array;
+    get lockTime(): number;
+    get version(): number;
+    private inputStatus;
+    private inputSighash;
+    private signStatus;
+    get isFinal(): boolean;
+    get hasWitnesses(): boolean;
+    get weight(): number;
+    get vsize(): number;
+    toBytes(withScriptSig?: boolean, withWitness?: boolean): Uint8Array;
+    get unsignedTx(): Bytes;
+    get hex(): string;
+    get hash(): string;
+    get id(): string;
+    private checkInputIdx;
+    getInput(idx: number): psbt.PSBTKeyMapKeys<{
+        readonly nonWitnessUtxo: readonly [0, false, P.CoderType<P.StructInput<{
+            version: number;
+            segwitFlag: boolean | undefined;
+            inputs: P.StructInput<{
+                txid: any;
+                index: any;
+                finalScriptSig: any;
+                sequence: any;
+            }>[];
+            outputs: P.StructInput<{
+                amount: any;
+                script: any;
+            }>[];
+            witnesses: P.Option<Uint8Array[][]>;
+            lockTime: number;
+        }>>, readonly [], readonly [0, 2], false];
+        readonly witnessUtxo: readonly [1, false, P.CoderType<P.StructInput<{
+            amount: bigint;
+            script: Uint8Array;
+        }>>, readonly [], readonly [0, 2], false];
+        readonly partialSig: readonly [2, P.CoderType<Uint8Array>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly sighashType: readonly [3, false, P.CoderType<number>, readonly [], readonly [0, 2], false];
+        readonly redeemScript: readonly [4, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly witnessScript: readonly [5, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly bip32Derivation: readonly [6, P.CoderType<Uint8Array>, P.CoderType<P.StructInput<{
+            fingerprint: number;
+            path: number[];
+        }>>, readonly [], readonly [0, 2], false];
+        readonly finalScriptSig: readonly [7, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly finalScriptWitness: readonly [8, false, P.CoderType<Uint8Array[]>, readonly [], readonly [0, 2], false];
+        readonly porCommitment: readonly [9, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly ripemd160: readonly [10, P.CoderType<Uint8Array>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly sha256: readonly [11, P.CoderType<Uint8Array>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly hash160: readonly [12, P.CoderType<Uint8Array>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly hash256: readonly [13, P.CoderType<Uint8Array>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly txid: readonly [14, false, P.CoderType<Uint8Array>, readonly [2], readonly [2], true];
+        readonly index: readonly [15, false, P.CoderType<number>, readonly [2], readonly [2], true];
+        readonly sequence: readonly [16, false, P.CoderType<number>, readonly [], readonly [2], true];
+        readonly requiredTimeLocktime: readonly [17, false, P.CoderType<number>, readonly [], readonly [2], false];
+        readonly requiredHeightLocktime: readonly [18, false, P.CoderType<number>, readonly [], readonly [2], false];
+        readonly tapKeySig: readonly [19, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly tapScriptSig: readonly [20, P.CoderType<P.StructInput<{
+            pubKey: Uint8Array;
+            leafHash: Uint8Array;
+        }>>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly tapLeafScript: readonly [21, P.CoderType<P.StructInput<{
+            version: number;
+            internalKey: Uint8Array;
+            merklePath: Uint8Array[];
+        }>>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly tapBip32Derivation: readonly [22, P.CoderType<Uint8Array>, P.CoderType<P.StructInput<{
+            hashes: Uint8Array[];
+            der: P.StructInput<{
+                fingerprint: any;
+                path: any;
+            }>;
+        }>>, readonly [], readonly [0, 2], false];
+        readonly tapInternalKey: readonly [23, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly tapMerkleRoot: readonly [24, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly proprietary: readonly [252, P.CoderType<Uint8Array>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+    }>;
+    get inputsLength(): number;
+    addInput(input: psbt.TransactionInputUpdate, _ignoreSignStatus?: boolean): number;
+    updateInput(idx: number, input: psbt.TransactionInputUpdate, _ignoreSignStatus?: boolean): void;
+    private checkOutputIdx;
+    getOutput(idx: number): psbt.PSBTKeyMapKeys<{
+        readonly redeemScript: readonly [0, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly witnessScript: readonly [1, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly bip32Derivation: readonly [2, P.CoderType<Uint8Array>, P.CoderType<P.StructInput<{
+            fingerprint: number;
+            path: number[];
+        }>>, readonly [], readonly [0, 2], false];
+        readonly amount: readonly [3, false, P.CoderType<bigint>, readonly [2], readonly [2], true];
+        readonly script: readonly [4, false, P.CoderType<Uint8Array>, readonly [2], readonly [2], true];
+        readonly tapInternalKey: readonly [5, false, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+        readonly tapTree: readonly [6, false, P.CoderType<P.StructInput<{
+            depth: number;
+            version: number;
+            script: Uint8Array;
+        }>[]>, readonly [], readonly [0, 2], false];
+        readonly tapBip32Derivation: readonly [7, P.CoderType<Uint8Array>, P.CoderType<P.StructInput<{
+            hashes: Uint8Array[];
+            der: P.StructInput<{
+                fingerprint: any;
+                path: any;
+            }>;
+        }>>, readonly [], readonly [0, 2], false];
+        readonly proprietary: readonly [252, P.CoderType<Uint8Array>, P.CoderType<Uint8Array>, readonly [], readonly [0, 2], false];
+    }>;
+    getOutputAddress(idx: number, network?: {
+        bech32: string;
+        pubKeyHash: number;
+        scriptHash: number;
+        wif: number;
+    }): string | undefined;
+    get outputsLength(): number;
+    private normalizeOutput;
+    addOutput(o: psbt.TransactionOutputUpdate, _ignoreSignStatus?: boolean): number;
+    updateOutput(idx: number, output: psbt.TransactionOutputUpdate, _ignoreSignStatus?: boolean): void;
+    addOutputAddress(address: string, amount: bigint, network?: {
+        bech32: string;
+        pubKeyHash: number;
+        scriptHash: number;
+        wif: number;
+    }): number;
+    get fee(): bigint;
+    private preimageLegacy;
+    preimageWitnessV0(idx: number, prevOutScript: Bytes, hashType: number, amount: bigint): Uint8Array;
+    preimageWitnessV1(idx: number, prevOutScript: Bytes[], hashType: number, amount: bigint[], codeSeparator?: number, leafScript?: Bytes, leafVer?: number, annex?: Bytes): Uint8Array;
+    signIdx(privateKey: Signer, idx: number, allowedSighash?: SigHash[], _auxRand?: Bytes): boolean;
+    sign(privateKey: Signer, allowedSighash?: number[], _auxRand?: Bytes): number;
+    finalizeIdx(idx: number): void;
+    finalize(): void;
+    extract(): Uint8Array;
+    combine(other: Transaction): this;
+    clone(): Transaction;
+}
+export declare function PSBTCombine(psbts: Bytes[]): Bytes;
+export declare function bip32Path(path: string): number[];
+export {};
+//# sourceMappingURL=transaction.d.ts.map

package/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["src/transaction.ts"],"names":[],"mappings":"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"}

package/{lib/transaction.js → transaction.js}

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bip32Path = exports.PSBTCombine = exports.Transaction = exports.inputBeforeSign = exports.SigHash = exports.SignatureHash = exports.cloneDeep = exports.def = exports.Decimal = exports.DEFAULT_SEQUENCE = exports.DEFAULT_LOCKTIME = exports.DEFAULT_VERSION = exports.PRECISION = void 0;
+exports.Transaction = exports.SigHash = exports.SignatureHash = exports.def = exports.Decimal = exports.DEFAULT_SEQUENCE = exports.DEFAULT_LOCKTIME = exports.DEFAULT_VERSION = exports.PRECISION = void 0;
+exports.cloneDeep = cloneDeep;
+exports.inputBeforeSign = inputBeforeSign;
+exports.PSBTCombine = PSBTCombine;
+exports.bip32Path = bip32Path;
 const P = require("micro-packed");
 const base_1 = require("@scure/base");
 const payment_js_1 = require("./payment.js");
 const psbt = require("./psbt.js"); // circular
 const script_js_1 = require("./script.js");
+const script_js_2 = require("./script.js");
 const utils_js_1 = require("./utils.js");
 const u = require("./utils.js");
 const utxo_js_1 = require("./utxo.js"); // circular
@@ -40,7 +45,6 @@ function cloneDeep(obj) {
     }
     throw new Error(`cloneDeep: unknown type=${obj} (${typeof obj})`);
 }
-exports.cloneDeep = cloneDeep;
 /**
  * Internal, exported only for backwards-compat. Use `SigHash` instead.
  * @deprecated
@@ -88,7 +92,6 @@ function inputBeforeSign(i) {
         finalScriptSig: (0, exports.def)(i.finalScriptSig, P.EMPTY),
     };
 }
-exports.inputBeforeSign = inputBeforeSign;
 function cleanFinalInput(i) {
     for (const _k in i) {
         const k = _k;
@@ -177,7 +180,7 @@ class Transaction {
     }
     // Import
     static fromRaw(raw, opts = {}) {
-        const parsed = script_js_1.RawTx.decode(raw);
+        const parsed = script_js_2.RawTx.decode(raw);
         const tx = new Transaction({ ...opts, version: parsed.version, lockTime: parsed.lockTime });
         for (const o of parsed.outputs)
             tx.addOutput(o);
@@ -231,6 +234,11 @@ class Transaction {
     toPSBT(PSBTVersion = this.opts.PSBTVersion) {
         if (PSBTVersion !== 0 && PSBTVersion !== 2)
             throw new Error(`Wrong PSBT version=${PSBTVersion}`);
+        // if (PSBTVersion === 0 && this.inputs.length === 0) {
+        //   throw new Error(
+        //     'PSBT version=0 export for transaction without inputs disabled, please use version=2. Please check `toPSBT` method for explanation.'
+        //   );
+        // }
         const inputs = this.inputs.map((i) => psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTInput, i));
         for (const inp of inputs) {
             // Don't serialize empty fields
@@ -244,7 +252,21 @@ class Transaction {
         const outputs = this.outputs.map((i) => psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTOutput, i));
         const global = { ...this.global };
         if (PSBTVersion === 0) {
-            global.unsignedTx = script_js_1.RawTx.decode(this.unsignedTx);
+            /*
+            - Bitcoin raw transaction expects to have at least 1 input because it uses case with zero inputs as marker for SegWit
+            - this means we cannot serialize raw tx with zero inputs since it will be parsed as SegWit tx
+            - 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_js_2.RawOldTx.decode(script_js_2.RawOldTx.encode({
+                version: this.version,
+                lockTime: this.lockTime,
+                inputs: this.inputs.map(inputBeforeSign).map((i) => ({
+                    ...i,
+                    finalScriptSig: P.EMPTY,
+                })),
+                outputs: this.outputs.map(outputBeforeSign),
+            }));
             delete global.fallbackLocktime;
             delete global.txVersion;
         }
@@ -390,7 +412,7 @@ class Transaction {
         for (const i of this.inputs) {
             out += 160 + 4 * script_js_1.VarBytes.encode(i.finalScriptSig || P.EMPTY).length;
             if (this.hasWitnesses && i.finalScriptWitness)
-                out += script_js_1.RawWitness.encode(i.finalScriptWitness).length;
+                out += script_js_2.RawWitness.encode(i.finalScriptWitness).length;
         }
         return out;
     }
@@ -398,7 +420,7 @@ class Transaction {
         return (0, utxo_js_1.toVsize)(this.weight);
     }
     toBytes(withScriptSig = false, withWitness = false) {
-        return script_js_1.RawTx.encode({
+        return script_js_2.RawTx.encode({
             version: this.version,
             lockTime: this.lockTime,
             inputs: this.inputs.map(inputBeforeSign).map((i) => ({
@@ -464,6 +486,12 @@ class Transaction {
         this.checkOutputIdx(idx);
         return cloneDeep(this.outputs[idx]);
     }
+    getOutputAddress(idx, network = utils_js_1.NETWORK) {
+        const out = this.getOutput(idx);
+        if (!out.script)
+            return;
+        return (0, payment_js_1.Address)(network).encode(payment_js_1.OutScript.decode(out.script));
+    }
     get outputsLength() {
         return this.outputs.length;
     }
@@ -472,7 +500,7 @@ class Transaction {
         if (amount === undefined)
             amount = cur?.amount;
         if (typeof amount !== 'bigint')
-            throw new Error('amount must be bigint sats');
+            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);
         if (script === undefined)
@@ -555,7 +583,7 @@ class Transaction {
         else if (isSingle) {
             outputs = outputs.slice(0, idx).fill(EMPTY_OUTPUT).concat([outputs[idx]]);
         }
-        const tmpTx = script_js_1.RawTx.encode({
+        const tmpTx = script_js_2.RawTx.encode({
             lockTime: this.lockTime,
             version: this.version,
             segwitFlag: false,
@@ -576,10 +604,10 @@ 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_js_1.RawOutput.encode));
+            outputHash = u.sha256x2(...outputs.map(script_js_2.RawOutput.encode));
         }
         else if (isSingle && idx < outputs.length)
-            outputHash = u.sha256x2(script_js_1.RawOutput.encode(outputs[idx]));
+            outputHash = u.sha256x2(script_js_2.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_js_1.VarBytes.encode(prevOutScript), P.U64LE.encode(amount), P.U32LE.encode(input.sequence), outputHash, P.U32LE.encode(this.lockTime), P.U32LE.encode(hashType));
     }
@@ -607,7 +635,7 @@ class Transaction {
             ].map((i) => u.sha256((0, utils_js_1.concatBytes)(...i))));
         }
         if (outType === SignatureHash.ALL) {
-            out.push(u.sha256((0, utils_js_1.concatBytes)(...outputs.map(script_js_1.RawOutput.encode))));
+            out.push(u.sha256((0, utils_js_1.concatBytes)(...outputs.map(script_js_2.RawOutput.encode))));
         }
         const spendType = (annex ? 1 : 0) | (leafScript ? 2 : 0);
         out.push(new Uint8Array([spendType]));
@@ -620,7 +648,7 @@ class Transaction {
         if (spendType & 1)
             out.push(u.sha256(script_js_1.VarBytes.encode(annex || P.EMPTY)));
         if (outType === SignatureHash.SINGLE)
-            out.push(idx < outputs.length ? u.sha256(script_js_1.RawOutput.encode(outputs[idx])) : EMPTY32);
+            out.push(idx < outputs.length ? u.sha256(script_js_2.RawOutput.encode(outputs[idx])) : EMPTY32);
         if (leafScript)
             out.push((0, payment_js_1.tapLeafHash)(leafScript, leafVer), P.U8.encode(0), P.I32LE.encode(codeSeparator));
         return u.tagSchnorr('TapSighash', ...out);
@@ -676,8 +704,6 @@ class Transaction {
         // Taproot
         const prevOut = (0, utxo_js_1.getPrevOut)(input);
         if (inputType.txType === 'taproot') {
-            if (input.tapBip32Derivation)
-                throw new Error('tapBip32Derivation unsupported');
             const prevOuts = this.inputs.map(utxo_js_1.getPrevOut);
             const prevOutScript = prevOuts.map((i) => i.script);
             const amount = prevOuts.map((i) => i.amount);
@@ -969,8 +995,10 @@ class Transaction {
                 throw new Error(`Transaction/combine: different ${k} length this=${this[k].length} other=${other[k].length}`);
             }
         }
-        const thisUnsigned = this.global.unsignedTx ? script_js_1.RawTx.encode(this.global.unsignedTx) : P.EMPTY;
-        const otherUnsigned = other.global.unsignedTx ? script_js_1.RawTx.encode(other.global.unsignedTx) : P.EMPTY;
+        const thisUnsigned = this.global.unsignedTx ? script_js_2.RawOldTx.encode(this.global.unsignedTx) : P.EMPTY;
+        const otherUnsigned = other.global.unsignedTx
+            ? script_js_2.RawOldTx.encode(other.global.unsignedTx)
+            : P.EMPTY;
         if (!(0, utils_js_1.equalBytes)(thisUnsigned, otherUnsigned))
             throw new Error(`Transaction/combine: different unsigned tx`);
         this.global = psbt.mergeKeyMap(psbt.PSBTGlobal, this.global, other.global);
@@ -994,7 +1022,6 @@ function PSBTCombine(psbts) {
         tx.combine(Transaction.fromPSBT(psbts[i]));
     return tx.toPSBT();
 }
-exports.PSBTCombine = PSBTCombine;
 // Copy-pasted from bip32 derive, maybe do something like 'bip32.parsePath'?
 const HARDENED_OFFSET = 0x80000000;
 function bip32Path(path) {
@@ -1018,5 +1045,4 @@ function bip32Path(path) {
     }
     return out;
 }
-exports.bip32Path = bip32Path;
 //# sourceMappingURL=transaction.js.map