@scure/btc-signer 1.3.1 → 1.4.0

package/src/transaction.ts

@@ -1,10 +1,10 @@
 import * as P from 'micro-packed';
 import { hex } from '@scure/base';
-
 import { Address, CustomScript, OutScript, checkScript, tapLeafHash } from './payment.js';
 import * as psbt from './psbt.js'; // circular
-import { CompactSizeLen, RawOutput, RawTx, RawWitness, Script, VarBytes } from './script.js';
-import { NETWORK, Bytes, concatBytes, isBytes } from './utils.js';
+import { CompactSizeLen, Script, VarBytes } from './script.js';
+import { RawOutput, RawTx, RawOldTx, RawWitness } from './script.js';
+import { NETWORK, Bytes, concatBytes, isBytes, equalBytes } from './utils.js';
 import * as u from './utils.js';
 import { getInputType, toVsize, normalizeInput, getPrevOut } from './utxo.js'; // circular
 
@@ -108,7 +108,7 @@ function getTaprootKeys(
   internalKey: Bytes,
   merkleRoot: Bytes = P.EMPTY
 ) {
-  if (P.equalBytes(internalKey, pubKey)) {
+  if (equalBytes(internalKey, pubKey)) {
     privKey = u.taprootTweakPrivKey(privKey, merkleRoot);
     pubKey = u.pubSchnorr(privKey);
   }
@@ -284,6 +284,11 @@ export 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
@@ -294,7 +299,23 @@ export class Transaction {
     const outputs = this.outputs.map((i) => psbt.cleanPSBTFields(PSBTVersion, psbt.PSBTOutput, i));
     const global = { ...this.global };
     if (PSBTVersion === 0) {
-      global.unsignedTx = 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 = RawOldTx.decode(
+        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;
     } else {
@@ -502,6 +523,12 @@ export class Transaction {
     this.checkOutputIdx(idx);
     return cloneDeep(this.outputs[idx]);
   }
+  getOutputAddress(idx: number, network = NETWORK): string | undefined {
+    const out = this.getOutput(idx);
+    if (!out.script) return;
+    return Address(network).encode(OutScript.decode(out.script));
+  }
+
   get outputsLength() {
     return this.outputs.length;
   }
@@ -512,7 +539,10 @@ export class Transaction {
   ): psbt.TransactionOutput {
     let { amount, script } = o;
     if (amount === undefined) amount = cur?.amount;
-    if (typeof amount !== 'bigint') throw new Error('amount must be bigint sats');
+    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 = hex.decode(script);
     if (script === undefined) script = cur?.script;
     let res: psbt.PSBTKeyMapKeys<typeof psbt.PSBTOutput> = { ...cur, ...o, amount, script };
@@ -700,7 +730,7 @@ export class Transaction {
         .map(([pubKey, { path }]) => {
           let s = privateKey as HDKey;
           for (const i of path) s = s.deriveChild(i);
-          if (!P.equalBytes(s.publicKey, pubKey)) throw new Error('bip32Derivation: wrong pubKey');
+          if (!equalBytes(s.publicKey, pubKey)) throw new Error('bip32Derivation: wrong pubKey');
           if (!s.privateKey) throw new Error('bip32Derivation: no privateKey');
           return s;
         });
@@ -735,7 +765,6 @@ export class Transaction {
     // Taproot
     const prevOut = getPrevOut(input);
     if (inputType.txType === 'taproot') {
-      if (input.tapBip32Derivation) throw new Error('tapBip32Derivation unsupported');
       const prevOuts = this.inputs.map(getPrevOut);
       const prevOutScript = prevOuts.map((i) => i.script);
       const amount = prevOuts.map((i) => i.amount);
@@ -754,7 +783,7 @@ export class Transaction {
           merkleRoot
         );
         const [taprootPubKey, _] = u.taprootTweakPubkey(input.tapInternalKey, merkleRoot);
-        if (P.equalBytes(taprootPubKey, pubKey)) {
+        if (equalBytes(taprootPubKey, pubKey)) {
           const hash = this.preimageWitnessV1(idx, prevOutScript, sighash, amount);
           const sig = concatBytes(
             u.signSchnorr(hash, privKey, _auxRand),
@@ -772,7 +801,7 @@ export class Transaction {
           const ver = _script[_script.length - 1];
           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) => isBytes(i) && P.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(
@@ -806,8 +835,7 @@ export class Transaction {
       let hasPubkey = false;
       const pubKeyHash = u.hash160(pubKey);
       for (const i of Script.decode(inputType.lastScript)) {
-        if (isBytes(i) && (P.equalBytes(i, pubKey) || P.equalBytes(i, pubKeyHash)))
-          hasPubkey = true;
+        if (isBytes(i) && (equalBytes(i, pubKey) || equalBytes(i, pubKeyHash))) hasPubkey = true;
       }
       if (!hasPubkey) throw new Error(`Input script doesn't have pubKey: ${inputType.lastScript}`);
       let hash;
@@ -870,14 +898,14 @@ export class Transaction {
           const ver = _script[_script.length - 1];
           const outScript = OutScript.decode(script);
           const hash = tapLeafHash(script, ver);
-          const scriptSig = input.tapScriptSig.filter((i) => P.equalBytes(i[0].leafHash, hash));
+          const scriptSig = input.tapScriptSig.filter((i) => equalBytes(i[0].leafHash, hash));
           let signatures: Bytes[] = [];
           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) => P.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);
@@ -890,7 +918,7 @@ export class Transaction {
             if (added !== m) continue;
           } else if (outScript.type === 'tr_ns') {
             for (const pub of outScript.pubkeys) {
-              const sigIdx = scriptSig.findIndex((i) => P.equalBytes(i[0].pubKey, pub));
+              const sigIdx = scriptSig.findIndex((i) => equalBytes(i[0].pubKey, pub));
               if (sigIdx === -1) continue;
               signatures.push(scriptSig[sigIdx][1]);
             }
@@ -900,7 +928,7 @@ export class Transaction {
             const scriptDecoded = Script.decode(script);
             signatures = scriptSig
               .map(([{ pubKey }, signature]) => {
-                const pos = scriptDecoded.findIndex((i) => isBytes(i) && P.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 };
@@ -951,7 +979,7 @@ export class Transaction {
       let signatures = [];
       // partial: [pubkey, sign]
       for (const pub of pubkeys) {
-        const sign = input.partialSig.find((s) => P.equalBytes(pub, s[0]));
+        const sign = input.partialSig.find((s) => equalBytes(pub, s[0]));
         if (!sign) continue;
         signatures.push(sign[1]);
       }
@@ -1022,9 +1050,11 @@ export class Transaction {
         );
       }
     }
-    const thisUnsigned = this.global.unsignedTx ? RawTx.encode(this.global.unsignedTx) : P.EMPTY;
-    const otherUnsigned = other.global.unsignedTx ? RawTx.encode(other.global.unsignedTx) : P.EMPTY;
-    if (!P.equalBytes(thisUnsigned, otherUnsigned))
+    const thisUnsigned = this.global.unsignedTx ? RawOldTx.encode(this.global.unsignedTx) : P.EMPTY;
+    const otherUnsigned = other.global.unsignedTx
+      ? RawOldTx.encode(other.global.unsignedTx)
+      : P.EMPTY;
+    if (!equalBytes(thisUnsigned, otherUnsigned))
       throw new Error(`Transaction/combine: different unsigned tx`);
     this.global = psbt.mergeKeyMap(psbt.PSBTGlobal, this.global, other.global);
     for (let i = 0; i < this.inputs.length; i++) this.updateInput(i, other.inputs[i], true);

package/src/utils.ts

@@ -1,4 +1,4 @@
-import { isBytes, concatBytes, U32LE } from 'micro-packed';
+import { utils as packedUtils, U32LE } from 'micro-packed';
 import { ripemd160 } from '@noble/hashes/ripemd160';
 import { sha256 } from '@noble/hashes/sha256';
 import { secp256k1 as secp, schnorr } from '@noble/curves/secp256k1';
@@ -7,7 +7,8 @@ export type Bytes = Uint8Array;
 const Point = secp.ProjectivePoint;
 const CURVE_ORDER = secp.CURVE.n;
 
-export { sha256, isBytes, concatBytes };
+const { isBytes, concatBytes, equalBytes } = packedUtils;
+export { sha256, isBytes, concatBytes, equalBytes };
 
 export const hash160 = (msg: Bytes) => ripemd160(sha256(msg));
 export const sha256x2 = (...msgs: Bytes[]) => sha256(sha256(concatBytes(...msgs)));

package/src/utxo.ts

@@ -10,7 +10,15 @@ import {
   SignatureHash,
   Transaction,
 } from './transaction.js'; // circular
-import { NETWORK, Bytes, compareBytes, isBytes, TAPROOT_UNSPENDABLE_KEY, sha256 } from './utils.js';
+import {
+  NETWORK,
+  Bytes,
+  compareBytes,
+  equalBytes,
+  isBytes,
+  TAPROOT_UNSPENDABLE_KEY,
+  sha256,
+} from './utils.js';
 import { validatePubkey, PubT } from './utils.js';
 
 // Normalizes input
@@ -153,7 +161,7 @@ function iterLeafs(tapLeafScript: TapLeafScript, sigSize: number, customScripts?
         const csEncoded = c.encode(scriptDecoded);
         if (csEncoded === undefined) continue;
         const pubKeys = scriptDecoded.filter((i) => {
-          if (!P.isBytes(i)) return false;
+          if (!isBytes(i)) return false;
           try {
             validatePubkey(i, PubT.schnorr);
             return true;
@@ -187,7 +195,7 @@ function estimateInput(
   // schnorr sig is always 64 bytes. except for cases when sighash is not default!
   if (inputType.txType === 'taproot') {
     const SCHNORR_SIG_SIZE = inputType.sighash !== SignatureHash.DEFAULT ? 65 : 64;
-    if (input.tapInternalKey && !P.equalBytes(input.tapInternalKey, TAPROOT_UNSPENDABLE_KEY)) {
+    if (input.tapInternalKey && !equalBytes(input.tapInternalKey, TAPROOT_UNSPENDABLE_KEY)) {
       witness = [new Uint8Array(SCHNORR_SIG_SIZE)];
     } else if (input.tapLeafScript) {
       witness = iterLeafs(input.tapLeafScript, SCHNORR_SIG_SIZE, opts.customScripts);
@@ -260,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) {
@@ -274,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'
@@ -302,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>;
@@ -309,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
@@ -348,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);
@@ -359,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;
   }
@@ -389,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));
   }
@@ -400,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();
@@ -409,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)
@@ -425,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];
@@ -433,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'
@@ -448,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) {
@@ -469,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
@@ -523,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