@scure/btc-signer 1.4.0 → 1.6.0

package/src/transaction.ts

@@ -1,12 +1,19 @@
-import * as P from 'micro-packed';
 import { hex } from '@scure/base';
-import { Address, CustomScript, OutScript, checkScript, tapLeafHash } from './payment.js';
+import * as P from 'micro-packed';
+import { Address, type CustomScript, OutScript, checkScript, tapLeafHash } from './payment.js';
 import * as psbt from './psbt.js'; // circular
-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 {
+  CompactSizeLen,
+  RawOldTx,
+  RawOutput,
+  RawTx,
+  RawWitness,
+  Script,
+  VarBytes,
+} from './script.js';
 import * as u from './utils.js';
-import { getInputType, toVsize, normalizeInput, getPrevOut } from './utxo.js'; // circular
+import { type Bytes, NETWORK, concatBytes, equalBytes, isBytes } from './utils.js';
+import { getInputType, getPrevOut, normalizeInput, toVsize } from './utxo.js'; // circular
 
 const EMPTY32 = new Uint8Array(32);
 const EMPTY_OUTPUT: P.UnwrapCoder<typeof RawOutput> = {
@@ -30,15 +37,15 @@ 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);
+export const Decimal: P.Coder<bigint, string> = P.coders.decimal(PRECISION);
 
 // Same as value || def, but doesn't overwrites zero ('0', 0, 0n, etc)
-export const def = <T>(value: T | undefined, def: T) => (value === undefined ? def : value);
+export const def = <T>(value: T | undefined, def: T): T => (value === undefined ? def : value);
 
 export function cloneDeep<T>(obj: T): T {
   if (Array.isArray(obj)) return obj.map((i) => cloneDeep(i)) as unknown as T;
   // slice of nodejs Buffer doesn't copy
-  else if (obj instanceof Uint8Array) return Uint8Array.from(obj) as unknown as T;
+  else if (isBytes(obj)) return Uint8Array.from(obj) as unknown as T;
   // immutable
   else if (['number', 'bigint', 'boolean', 'string', 'undefined'].includes(typeof obj)) return obj;
   // null is object
@@ -166,7 +173,7 @@ function unpackSighash(hashType: number) {
   };
 }
 
-function validateOpts(opts: TxOpts) {
+function validateOpts(opts: TxOpts): Readonly<TxOpts> {
   if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
     throw new Error(`Wrong object type for transaction options: ${opts}`);
 
@@ -182,7 +189,8 @@ function validateOpts(opts: TxOpts) {
   if (typeof _opts.allowUnknowOutput !== 'undefined')
     opts.allowUnknownOutputs = _opts.allowUnknowOutput;
   // 0 and -1 happens in tests
-  if (![-1, 0, 1, 2].includes(_opts.version)) throw new Error(`Unknown version: ${_opts.version}`);
+  if (![-1, 0, 1, 2, 3].includes(_opts.version))
+    throw new Error(`Unknown version: ${_opts.version}`);
   if (typeof _opts.lockTime !== 'number') throw new Error('Transaction lock time should be number');
   P.U32LE.encode(_opts.lockTime); // Additional range checks that lockTime
   // There is no PSBT v1, and any new version will probably have fields which we don't know how to parse, which
@@ -233,7 +241,7 @@ export class Transaction {
   }
 
   // Import
-  static fromRaw(raw: Bytes, opts: TxOpts = {}) {
+  static fromRaw(raw: Bytes, opts: TxOpts = {}): Transaction {
     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);
@@ -246,7 +254,7 @@ export class Transaction {
     return tx;
   }
   // PSBT
-  static fromPSBT(psbt_: Bytes, opts: TxOpts = {}) {
+  static fromPSBT(psbt_: Bytes, opts: TxOpts = {}): Transaction {
     let parsed: P.UnwrapCoder<typeof psbt.RawPSBTV0>;
     try {
       parsed = psbt.RawPSBTV0.decode(psbt_);
@@ -281,7 +289,7 @@ export class Transaction {
     if (lockTime !== DEFAULT_LOCKTIME) tx.global.fallbackLocktime = lockTime;
     return tx;
   }
-  toPSBT(PSBTVersion = this.opts.PSBTVersion) {
+  toPSBT(PSBTVersion: number | undefined = this.opts.PSBTVersion): Uint8Array {
     if (PSBTVersion !== 0 && PSBTVersion !== 2)
       throw new Error(`Wrong PSBT version=${PSBTVersion}`);
     // if (PSBTVersion === 0 && this.inputs.length === 0) {
@@ -338,7 +346,7 @@ export class Transaction {
   }
 
   // BIP370 lockTime (https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#determining-lock-time)
-  get lockTime() {
+  get lockTime(): number {
     let height = DEFAULT_LOCKTIME;
     let heightCnt = 0;
     let time = DEFAULT_LOCKTIME;
@@ -358,7 +366,7 @@ export class Transaction {
     return this.global.fallbackLocktime || DEFAULT_LOCKTIME;
   }
 
-  get version() {
+  get version(): number {
     // Should be not possible
     if (this.global.txVersion === undefined) throw new Error('No global.txVersion');
     return this.global.txVersion;
@@ -381,7 +389,8 @@ export class Transaction {
   // We will lose some vectors -> smaller test coverage of preimages (very important!)
   private inputSighash(idx: number) {
     this.checkInputIdx(idx);
-    const sighash = getInputType(this.inputs[idx], this.opts.allowLegacyWitnessUtxo).sighash;
+    const inputSighash = this.inputs[idx].sighashType;
+    const sighash = inputSighash === undefined ? SignatureHash.DEFAULT : inputSighash;
     // ALL or DEFAULT -- everything signed
     // NONE           -- all inputs + no outputs
     // SINGLE         -- all inputs + output with same index
@@ -418,7 +427,7 @@ export class Transaction {
     return { addInput, addOutput, inputs, outputs };
   }
 
-  get isFinal() {
+  get isFinal(): boolean {
     for (let idx = 0; idx < this.inputs.length; idx++)
       if (this.inputStatus(idx) !== 'finalized') return false;
     return true;
@@ -452,7 +461,7 @@ export class Transaction {
   get vsize(): number {
     return toVsize(this.weight);
   }
-  toBytes(withScriptSig = false, withWitness = false) {
+  toBytes(withScriptSig = false, withWitness = false): Uint8Array {
     return RawTx.encode({
       version: this.version,
       lockTime: this.lockTime,
@@ -468,15 +477,15 @@ export class Transaction {
   get unsignedTx(): Bytes {
     return this.toBytes(false, false);
   }
-  get hex() {
+  get hex(): string {
     return hex.encode(this.toBytes(true, this.hasWitnesses));
   }
 
-  get hash() {
+  get hash(): string {
     if (!this.isFinal) throw new Error('Transaction is not finalized');
     return hex.encode(u.sha256x2(this.toBytes(true)));
   }
-  get id() {
+  get id(): string {
     if (!this.isFinal) throw new Error('Transaction is not finalized');
     return hex.encode(u.sha256x2(this.toBytes(true)).reverse());
   }
@@ -485,11 +494,11 @@ export class Transaction {
     if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.inputs.length)
       throw new Error(`Wrong input index=${idx}`);
   }
-  getInput(idx: number) {
+  getInput(idx: number): psbt.TransactionInput {
     this.checkInputIdx(idx);
     return cloneDeep(this.inputs[idx]);
   }
-  get inputsLength() {
+  get inputsLength(): number {
     return this.inputs.length;
   }
   // Modification
@@ -499,7 +508,7 @@ export class Transaction {
     this.inputs.push(normalizeInput(input, undefined, undefined, this.opts.disableScriptCheck));
     return this.inputs.length - 1;
   }
-  updateInput(idx: number, input: psbt.TransactionInputUpdate, _ignoreSignStatus = false) {
+  updateInput(idx: number, input: psbt.TransactionInputUpdate, _ignoreSignStatus = false): void {
     this.checkInputIdx(idx);
     let allowedFields = undefined;
     if (!_ignoreSignStatus) {
@@ -519,17 +528,17 @@ export class Transaction {
     if (!Number.isSafeInteger(idx) || 0 > idx || idx >= this.outputs.length)
       throw new Error(`Wrong output index=${idx}`);
   }
-  getOutput(idx: number) {
+  getOutput(idx: number): psbt.TransactionOutput {
     this.checkOutputIdx(idx);
     return cloneDeep(this.outputs[idx]);
   }
-  getOutputAddress(idx: number, network = NETWORK): string | undefined {
+  getOutputAddress(idx: number, network: u.BTC_NETWORK = NETWORK): string | undefined {
     const out = this.getOutput(idx);
     if (!out.script) return;
     return Address(network).encode(OutScript.decode(out.script));
   }
 
-  get outputsLength() {
+  get outputsLength(): number {
     return this.outputs.length;
   }
   private normalizeOutput(
@@ -567,7 +576,7 @@ export class Transaction {
     this.outputs.push(this.normalizeOutput(o));
     return this.outputs.length - 1;
   }
-  updateOutput(idx: number, output: psbt.TransactionOutputUpdate, _ignoreSignStatus = false) {
+  updateOutput(idx: number, output: psbt.TransactionOutputUpdate, _ignoreSignStatus = false): void {
     this.checkOutputIdx(idx);
     let allowedFields = undefined;
     if (!_ignoreSignStatus) {
@@ -577,7 +586,7 @@ export class Transaction {
     }
     this.outputs[idx] = this.normalizeOutput(output, this.outputs[idx], allowedFields);
   }
-  addOutputAddress(address: string, amount: bigint, network = NETWORK): number {
+  addOutputAddress(address: string, amount: bigint, network: u.BTC_NETWORK = NETWORK): number {
     return this.addOutput({ script: OutScript.encode(Address(network).decode(address)), amount });
   }
   // Utils
@@ -632,7 +641,12 @@ export class Transaction {
     });
     return u.sha256x2(tmpTx, P.I32LE.encode(hashType));
   }
-  preimageWitnessV0(idx: number, prevOutScript: Bytes, hashType: number, amount: bigint) {
+  preimageWitnessV0(
+    idx: number,
+    prevOutScript: Bytes,
+    hashType: number,
+    amount: bigint
+  ): Uint8Array {
     const { isAny, isNone, isSingle } = unpackSighash(hashType);
     let inputHash = EMPTY32;
     let sequenceHash = EMPTY32;
@@ -670,7 +684,7 @@ export class Transaction {
     leafScript?: Bytes,
     leafVer = 0xc0,
     annex?: Bytes
-  ) {
+  ): Uint8Array {
     if (!Array.isArray(amount) || this.inputs.length !== amount.length)
       throw new Error(`Invalid amounts array=${amount}`);
     if (!Array.isArray(prevOutScript) || this.inputs.length !== prevOutScript.length)
@@ -877,7 +891,7 @@ export class Transaction {
     return num;
   }
 
-  finalizeIdx(idx: number) {
+  finalizeIdx(idx: number): void {
     this.checkInputIdx(idx);
     if (this.fee < 0n) throw new Error('Outputs spends more than inputs amount');
     const input = this.inputs[idx];
@@ -1026,10 +1040,10 @@ export class Transaction {
     if (finalScriptWitness) input.finalScriptWitness = finalScriptWitness;
     cleanFinalInput(input);
   }
-  finalize() {
+  finalize(): void {
     for (let i = 0; i < this.inputs.length; i++) this.finalizeIdx(i);
   }
-  extract() {
+  extract(): Uint8Array {
     if (!this.isFinal) throw new Error('Transaction has unfinalized inputs');
     if (!this.outputs.length) throw new Error('Transaction has no outputs');
     if (this.fee < 0n) throw new Error('Outputs spends more than inputs amount');
@@ -1061,7 +1075,7 @@ export class Transaction {
     for (let i = 0; i < this.outputs.length; i++) this.updateOutput(i, other.outputs[i], true);
     return this;
   }
-  clone() {
+  clone(): Transaction {
     // deepClone probably faster, but this enforces that encoding is valid
     return Transaction.fromPSBT(this.toPSBT(this.opts.PSBTVersion), this.opts);
   }

package/src/utils.ts

@@ -1,20 +1,24 @@
-import { utils as packedUtils, U32LE } from 'micro-packed';
+import { schnorr, secp256k1 as secp } from '@noble/curves/secp256k1';
 import { ripemd160 } from '@noble/hashes/ripemd160';
 import { sha256 } from '@noble/hashes/sha256';
-import { secp256k1 as secp, schnorr } from '@noble/curves/secp256k1';
+import { utils as packedUtils, U32LE } from 'micro-packed';
 
+export type Hex = string | Uint8Array;
 export type Bytes = Uint8Array;
 const Point = secp.ProjectivePoint;
 const CURVE_ORDER = secp.CURVE.n;
 
-const { isBytes, concatBytes, equalBytes } = packedUtils;
-export { sha256, isBytes, concatBytes, equalBytes };
+const isBytes: (a: unknown) => a is Uint8Array = packedUtils.isBytes;
+const concatBytes: (...arrays: Uint8Array[]) => Uint8Array = packedUtils.concatBytes;
+const equalBytes: (a: Uint8Array, b: Uint8Array) => boolean = packedUtils.equalBytes;
+export { concatBytes, equalBytes, isBytes, sha256 };
 
-export const hash160 = (msg: Bytes) => ripemd160(sha256(msg));
-export const sha256x2 = (...msgs: Bytes[]) => sha256(sha256(concatBytes(...msgs)));
-export const randomPrivateKeyBytes = schnorr.utils.randomPrivateKey;
+export const hash160 = (msg: Uint8Array): Uint8Array => ripemd160(sha256(msg));
+export const sha256x2 = (...msgs: Uint8Array[]): Uint8Array => sha256(sha256(concatBytes(...msgs)));
+export const randomPrivateKeyBytes: () => Uint8Array = schnorr.utils.randomPrivateKey;
 export const pubSchnorr = schnorr.getPublicKey as (priv: string | Uint8Array) => Uint8Array;
-export const pubECDSA = secp.getPublicKey;
+export const pubECDSA: (privateKey: string | Uint8Array, isCompressed?: boolean) => Uint8Array =
+  secp.getPublicKey;
 
 // low-r signature grinding. Used to reduce tx size by 1 byte.
 // noble/secp256k1 does not support the feature: it is not used outside of BTC.
@@ -35,8 +39,8 @@ export function signECDSA(hash: Bytes, privateKey: Bytes, lowR = false): Bytes {
   return sig.toDERRawBytes();
 }
 
-export const signSchnorr = schnorr.sign;
-export const tagSchnorr = schnorr.utils.taggedHash;
+export const signSchnorr: typeof schnorr.sign = schnorr.sign;
+export const tagSchnorr: typeof schnorr.utils.taggedHash = schnorr.utils.taggedHash;
 
 export enum PubT {
   ecdsa,
@@ -65,7 +69,7 @@ export function tapTweak(a: Bytes, b: Bytes): bigint {
   return tn;
 }
 
-export function taprootTweakPrivKey(privKey: Uint8Array, merkleRoot = new Uint8Array()) {
+export function taprootTweakPrivKey(privKey: Bytes, merkleRoot: Bytes = new Uint8Array()): Bytes {
   const u = schnorr.utils;
   const seckey0 = u.bytesToNumberBE(privKey); // seckey0 = int_from_bytes(seckey0)
   const P = Point.fromPrivateKey(seckey0); // P = point_mul(G, seckey0)
@@ -78,7 +82,7 @@ export function taprootTweakPrivKey(privKey: Uint8Array, merkleRoot = new Uint8A
   return u.numberToBytesBE(u.mod(seckey + t, CURVE_ORDER), 32);
 }
 
-export function taprootTweakPubkey(pubKey: Uint8Array, h: Uint8Array): [Uint8Array, number] {
+export function taprootTweakPubkey(pubKey: Bytes, h: Bytes): [Bytes, number] {
   const u = schnorr.utils;
   const t = tapTweak(pubKey, h); // t = int_from_bytes(tagged_hash("TapTweak", pubkey + h))
   const P = u.lift_x(u.bytesToNumberBE(pubKey)); // P = lift_x(int_from_bytes(pubkey))
@@ -93,16 +97,22 @@ export function taprootTweakPubkey(pubKey: Uint8Array, h: Uint8Array): [Uint8Arr
 // It is possible to switch SECP256K1_GENERATOR_POINT with some random point;
 // but it's too complex to prove.
 // Also used by bitcoin-core and bitcoinjs-lib
-export const TAPROOT_UNSPENDABLE_KEY = sha256(Point.BASE.toRawBytes(false));
+export const TAPROOT_UNSPENDABLE_KEY: Bytes = sha256(Point.BASE.toRawBytes(false));
 
-export const NETWORK = {
+export type BTC_NETWORK = {
+  bech32: string;
+  pubKeyHash: number;
+  scriptHash: number;
+  wif: number;
+};
+export const NETWORK: BTC_NETWORK = {
   bech32: 'bc',
   pubKeyHash: 0x00,
   scriptHash: 0x05,
   wif: 0x80,
 };
 
-export const TEST_NETWORK: typeof NETWORK = {
+export const TEST_NETWORK: BTC_NETWORK = {
   bech32: 'tb',
   pubKeyHash: 0x6f,
   scriptHash: 0xc4,
@@ -110,7 +120,7 @@ export const TEST_NETWORK: typeof NETWORK = {
 };
 
 // Exported for tests, internal method
-export function compareBytes(a: Bytes, b: Bytes) {
+export function compareBytes(a: Bytes, b: Bytes): number {
   if (!isBytes(a) || !isBytes(b)) throw new Error(`cmp: wrong type a=${typeof a} b=${typeof b}`);
   // -1 -> a<b, 0 -> a==b, 1 -> a>b
   const len = Math.min(a.length, b.length);

package/src/utxo.ts

@@ -1,25 +1,28 @@
 import { hex } from '@scure/base';
 import * as P from 'micro-packed';
-import { Address, CustomScript, OutScript, checkScript, tapLeafHash } from './payment.js';
+import { Address, type CustomScript, OutScript, checkScript, tapLeafHash } from './payment.js';
 import * as psbt from './psbt.js';
 import { CompactSizeLen, RawOutput, RawTx, RawWitness, Script, VarBytes } from './script.js';
 import {
   DEFAULT_SEQUENCE,
-  TxOpts,
-  inputBeforeSign,
   SignatureHash,
   Transaction,
+  type TxOpts,
+  inputBeforeSign,
 } from './transaction.js'; // circular
 import {
+  type Bytes,
   NETWORK,
-  Bytes,
+  PubT,
+  TAPROOT_UNSPENDABLE_KEY,
   compareBytes,
   equalBytes,
   isBytes,
-  TAPROOT_UNSPENDABLE_KEY,
   sha256,
+  validatePubkey,
 } from './utils.js';
-import { validatePubkey, PubT } from './utils.js';
+
+export type PSBTInputs = psbt.PSBTKeyMapKeys<typeof psbt.PSBTInput>;
 
 // Normalizes input
 export function getPrevOut(input: psbt.TransactionInput): P.UnwrapCoder<typeof RawOutput> {
@@ -48,7 +51,7 @@ export function normalizeInput(
   if (typeof txid === 'string') txid = hex.decode(txid);
   // TODO: if we have nonWitnessUtxo, we can extract txId from here
   if (txid === undefined) txid = cur?.txid;
-  let res: psbt.PSBTKeyMapKeys<typeof psbt.PSBTInput> = { ...cur, ...i, nonWitnessUtxo, txid };
+  let res: PSBTInputs = { ...cur, ...i, nonWitnessUtxo, txid };
   if (!('nonWitnessUtxo' in i) && res.nonWitnessUtxo === undefined) delete res.nonWitnessUtxo;
   if (res.sequence === undefined) res.sequence = DEFAULT_SEQUENCE;
   if (res.tapMerkleRoot === null) delete res.tapMerkleRoot;
@@ -122,9 +125,17 @@ export function getInputType(input: psbt.TransactionInput, allowLegacyWitnessUtx
   }
 }
 
-export const toVsize = (weight: number) => Math.ceil(weight / 4);
+export const toVsize = (weight: number): number => Math.ceil(weight / 4);
 // UTXO Select
-type Output = { address: string; amount: bigint } | { script: Uint8Array; amount: bigint };
+export type Output = { address: string; amount: bigint } | { script: Uint8Array; amount: bigint };
+export type Accumulated =
+  | {
+      indices: number[];
+      fee: bigint | undefined;
+      weight: number;
+      total: bigint;
+    }
+  | undefined;
 type TapLeafScript = psbt.TransactionInput['tapLeafScript'];
 type TB = Parameters<typeof psbt.TaprootControlBlock.encode>[0];
 const encodeTapBlock = (item: TB) => psbt.TaprootControlBlock.encode(item);
@@ -252,7 +263,7 @@ function estimateInput(
 }
 
 // Exported for tests, internal method
-export const _cmpBig = (a: bigint, b: bigint) => {
+export const _cmpBig = (a: bigint, b: bigint): 0 | 1 | -1 => {
   const n = a - b;
   if (n < 0n) return -1;
   else if (n > 0n) return 1;
@@ -276,7 +287,7 @@ export type EstimatorOpts = TxOpts & {
 
 function getScript(o: Output, opts: TxOpts = {}, network = NETWORK) {
   let script;
-  if ('script' in o && o.script instanceof Uint8Array) {
+  if ('script' in o && isBytes(o.script)) {
     script = o.script;
   }
   if ('address' in o) {
@@ -442,27 +453,27 @@ export class _Estimator {
   }
 
   // Sort by value instead of amount
-  get biggest() {
+  get biggest(): number[] {
     return this.normalizedInputs
       .map((_i, j) => j)
       .sort((a, b) => _cmpBig(this.normalizedInputs[b].value, this.normalizedInputs[a].value));
   }
-  get smallest() {
+  get smallest(): number[] {
     return this.biggest.reverse();
   }
   // These assume that UTXO array has historical order.
   // Otherwise, we have no way to know which tx is oldest
   // Explorers usually give UTXO in this order.
-  get oldest() {
+  get oldest(): number[] {
     return this.normalizedInputs.map((_i, j) => j);
   }
-  get newest() {
+  get newest(): number[] {
     return this.oldest.reverse();
   }
   // exact - like blackjack from coinselect.
   // 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) {
+  accumulate(indices: number[], exact = false, skipNegative = true, all = false): Accumulated {
     // TODO: how to handle change addresses?
     // - cost of input
     // - cost of change output (if input requires change)
@@ -524,7 +535,7 @@ export class _Estimator {
   }
 
   // Works like coinselect default method
-  default() {
+  default(): Accumulated {
     const { biggest } = this;
     const exact = this.accumulate(biggest, true, false);
     if (exact) return exact;
@@ -602,7 +613,8 @@ export class _Estimator {
       for (const o of outputs)
         tx.addOutput({ ...o, script: getScript(o, this.opts, this.opts.network) });
     }
-    return { ...res, tx };
+    return Object.assign(res, { tx });
+    // return { ...res, tx: tx };
   }
 }
 

package/transaction.d.ts

@@ -1,7 +1,8 @@
 import * as P from 'micro-packed';
-import { CustomScript } from './payment.js';
+import { type CustomScript } from './payment.js';
 import * as psbt from './psbt.js';
-import { Bytes } from './utils.js';
+import * as u from './utils.js';
+import { type Bytes } from './utils.js';
 interface HDKey {
     publicKey: Bytes;
     privateKey: Bytes;
@@ -15,10 +16,7 @@ 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 Decimal: P.Coder<bigint, string>;
 export declare const def: <T>(value: T | undefined, def: T) => T;
 export declare function cloneDeep<T>(obj: T): T;
 export type TxOpts = {
@@ -65,22 +63,7 @@ export type TransactionInputRequired = {
     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[];
-}>;
+declare function validateOpts(opts: TxOpts): Readonly<TxOpts>;
 export declare class Transaction {
     private global;
     private inputs;
@@ -89,7 +72,7 @@ export declare class Transaction {
     constructor(opts?: TxOpts);
     static fromRaw(raw: Bytes, opts?: TxOpts): Transaction;
     static fromPSBT(psbt_: Bytes, opts?: TxOpts): Transaction;
-    toPSBT(PSBTVersion?: number): Uint8Array;
+    toPSBT(PSBTVersion?: number | undefined): Uint8Array;
     get lockTime(): number;
     get version(): number;
     private inputStatus;
@@ -105,112 +88,18 @@ export declare class Transaction {
     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];
-    }>;
+    getInput(idx: number): psbt.TransactionInput;
     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;
+    getOutput(idx: number): psbt.TransactionOutput;
+    getOutputAddress(idx: number, network?: u.BTC_NETWORK): 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;
+    addOutputAddress(address: string, amount: bigint, network?: u.BTC_NETWORK): number;
     get fee(): bigint;
     private preimageLegacy;
     preimageWitnessV0(idx: number, prevOutScript: Bytes, hashType: number, amount: bigint): Uint8Array;