@btc-vision/bitcoin 6.3.0 → 6.3.2

package/src/{psbt.js → psbt.ts}

@@ -1,28 +1,85 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.prepareFinalScripts = exports.getFinalScripts = exports.Psbt = void 0;
-const bip174_1 = require('bip174');
-const varuint = require('bip174/src/lib/converter/varint');
-const utils_1 = require('bip174/src/lib/utils');
-const address_1 = require('./address');
-const bufferutils_1 = require('./bufferutils');
-const networks_1 = require('./networks');
-const payments = require('./payments');
-const bip341_1 = require('./payments/bip341');
-const bscript = require('./script');
-const transaction_1 = require('./transaction');
-const bip371_1 = require('./psbt/bip371');
-const psbtutils_1 = require('./psbt/psbtutils');
-const HookedSigner_js_1 = require('./hooks/HookedSigner.js');
+import { Psbt as PsbtBase } from 'bip174';
+import * as varuint from 'bip174/src/lib/converter/varint.js';
+import {
+    Bip32Derivation,
+    KeyValue,
+    PartialSig,
+    PsbtGlobal,
+    PsbtGlobalUpdate,
+    PsbtInput,
+    PsbtInputUpdate,
+    PsbtOutput,
+    PsbtOutputUpdate,
+    TapKeySig,
+    TapScriptSig,
+    Transaction as ITransaction,
+    TransactionFromBuffer,
+} from 'bip174/src/lib/interfaces.js';
+import { checkForInput, checkForOutput } from 'bip174/src/lib/utils.js';
+import { BIP32Interface } from 'bip32';
+import { ECPairInterface } from 'ecpair';
+import { fromOutputScript, toOutputScript } from './address.js';
+import { cloneBuffer, reverseBuffer } from './bufferutils.js';
+import { hookSigner } from './hooks/HookedSigner.js';
+import { payments } from './index.js';
+import { bitcoin as btcNetwork, Network } from './networks.js';
+import { tapleafHash } from './payments/bip341.js';
+import { Payment, PaymentOpts } from './payments/index.js';
+import {
+    checkTaprootInputFields,
+    checkTaprootInputForSigs,
+    checkTaprootOutputFields,
+    isTaprootInput,
+    serializeTaprootSignature,
+    tapScriptFinalizer,
+    toXOnly,
+} from './psbt/bip371.js';
+import {
+    checkInputForSig,
+    isP2MS,
+    isP2PK,
+    isP2PKH,
+    isP2SHScript,
+    isP2TR,
+    isP2WPKH,
+    isP2WSHScript,
+    pubkeyInScript,
+    witnessStackToScriptWitness,
+} from './psbt/psbtutils.js';
+import * as bscript from './script.js';
+import { Output, Transaction } from './transaction.js';
+
+export interface TransactionInput {
+    hash: string | Buffer;
+    index: number;
+    sequence?: number;
+}
+
+export interface PsbtTxInput extends TransactionInput {
+    hash: Buffer;
+}
+
+export interface TransactionOutput {
+    script: Buffer;
+    value: number;
+}
+
+export interface PsbtTxOutput extends TransactionOutput {
+    address: string | undefined;
+}
+
+// msghash is 32 byte hash of preimage, signature is 64 byte compact signature (r,s 32 bytes each)
+export type ValidateSigFunction = (pubkey: Buffer, msghash: Buffer, signature: Buffer) => boolean;
+
 /**
  * These are the default arguments for a Psbt instance.
  */
-const DEFAULT_OPTS = {
+const DEFAULT_OPTS: PsbtOpts = {
     /**
      * A bitcoinjs Network object. This is only used if you pass an `address`
      * parameter to addOutput. Otherwise it is not needed and can be left default.
      */
-    network: networks_1.bitcoin,
+    network: btcNetwork,
     /**
      * When extractTransaction is called, the fee rate is checked.
      * THIS IS NOT TO BE RELIED ON.
@@ -30,6 +87,13 @@ const DEFAULT_OPTS = {
      */
     maximumFeeRate: 5000, // satoshi per byte
 };
+
+// Not a breaking change.
+export interface PsbtBaseExtended extends Omit<PsbtBase, 'inputs'> {
+    inputs: PsbtInput[];
+    globalMap: PsbtGlobal;
+}
+
 /**
  * Psbt class can parse and generate a PSBT binary based off of the BIP174.
  * There are 6 roles that this class fulfills. (Explained in BIP174)
@@ -70,103 +134,112 @@ const DEFAULT_OPTS = {
 /**
  * Psbt class can parse and generate a PSBT binary based off of the BIP174.
  */
-class Psbt {
-    data;
-    __CACHE;
-    opts;
-    constructor(opts = {}, data = new bip174_1.Psbt(new PsbtTransaction())) {
-        this.data = data;
+export class Psbt {
+    private readonly __CACHE: PsbtCache;
+    private readonly opts: PsbtOpts;
+
+    constructor(
+        opts: PsbtOptsOptional = {},
+        public data: PsbtBaseExtended = new PsbtBase(new PsbtTransaction()),
+    ) {
         this.opts = Object.assign({}, DEFAULT_OPTS, opts);
         this.__CACHE = {
             __NON_WITNESS_UTXO_TX_CACHE: [],
             __NON_WITNESS_UTXO_BUF_CACHE: [],
             __TX_IN_CACHE: {},
             // @ts-expect-error no.
-            __TX: this.data.globalMap.unsignedTx.tx,
+            __TX: this.data.globalMap.unsignedTx.tx, // Now TypeScript knows unsignedTx is a PsbtTransaction
             __UNSAFE_SIGN_NONSEGWIT: false,
         };
         if (this.data.inputs.length === 0) this.setVersion(2);
-        const dpew = (obj, attr, enumerable, writable) => {
+
+        const dpew = <T>(obj: T, attr: string, enumerable: boolean, writable: boolean): void => {
             Object.defineProperty(obj, attr, {
                 enumerable,
                 writable,
             });
         };
+
         dpew(this, '__CACHE', false, true);
         dpew(this, 'opts', false, true);
     }
-    get inputCount() {
+
+    get inputCount(): number {
         return this.data.inputs.length;
     }
-    get version() {
+
+    get version(): number {
         return this.__CACHE.__TX.version;
     }
-    set version(version) {
+
+    set version(version: number) {
         this.setVersion(version);
     }
-    get locktime() {
+
+    get locktime(): number {
         return this.__CACHE.__TX.locktime;
     }
-    set locktime(locktime) {
+
+    set locktime(locktime: number) {
         this.setLocktime(locktime);
     }
-    get txInputs() {
-        return this.__CACHE.__TX.ins.map(input => ({
-            hash: (0, bufferutils_1.cloneBuffer)(input.hash),
+
+    get txInputs(): PsbtTxInput[] {
+        return this.__CACHE.__TX.ins.map((input) => ({
+            hash: cloneBuffer(input.hash),
             index: input.index,
             sequence: input.sequence,
         }));
     }
-    get txOutputs() {
-        return this.__CACHE.__TX.outs.map(output => {
+
+    get txOutputs(): PsbtTxOutput[] {
+        return this.__CACHE.__TX.outs.map((output) => {
             let address;
             try {
-                address = (0, address_1.fromOutputScript)(
-                    output.script,
-                    this.opts.network,
-                );
+                address = fromOutputScript(output.script, this.opts.network);
             } catch (_) {}
             return {
-                script: (0, bufferutils_1.cloneBuffer)(output.script),
+                script: cloneBuffer(output.script),
                 value: output.value,
                 address,
             };
         });
     }
-    static fromBase64(data, opts = {}) {
+
+    static fromBase64(data: string, opts: PsbtOptsOptional = {}): Psbt {
         const buffer = Buffer.from(data, 'base64');
         return this.fromBuffer(buffer, opts);
     }
-    static fromHex(data, opts = {}) {
+
+    static fromHex(data: string, opts: PsbtOptsOptional = {}): Psbt {
         const buffer = Buffer.from(data, 'hex');
         return this.fromBuffer(buffer, opts);
     }
-    static fromBuffer(buffer, opts = {}) {
-        const psbtBase = bip174_1.Psbt.fromBuffer(
-            buffer,
-            transactionFromBuffer,
-        );
+
+    static fromBuffer(buffer: Buffer, opts: PsbtOptsOptional = {}): Psbt {
+        const psbtBase = PsbtBase.fromBuffer(buffer, transactionFromBuffer);
         const psbt = new Psbt(opts, psbtBase);
         checkTxForDupeIns(psbt.__CACHE.__TX, psbt.__CACHE);
         return psbt;
     }
-    combine(...those) {
-        this.data.combine(...those.map(o => o.data));
+
+    combine(...those: Psbt[]): this {
+        this.data.combine(...those.map((o) => o.data));
         return this;
     }
-    clone() {
+
+    clone(): Psbt {
         // TODO: more efficient cloning
-        const res = Psbt.fromBuffer(
-            this.data.toBuffer(),
-            JSON.parse(JSON.stringify(this.opts)),
-        );
+        const res = Psbt.fromBuffer(this.data.toBuffer(), JSON.parse(JSON.stringify(this.opts)));
         return res;
     }
-    setMaximumFeeRate(satoshiPerByte) {
+
+    setMaximumFeeRate(satoshiPerByte: number): void {
         check32Bit(satoshiPerByte); // 42.9 BTC per byte IS excessive... so throw
         this.opts.maximumFeeRate = satoshiPerByte;
     }
-    setVersion(version) {
+
+    setVersion(version: number): this {
         check32Bit(version);
         checkInputsForPartialSig(this.data.inputs, 'setVersion');
         const c = this.__CACHE;
@@ -174,7 +247,8 @@ class Psbt {
         c.__EXTRACTED_TX = undefined;
         return this;
     }
-    setLocktime(locktime) {
+
+    setLocktime(locktime: number): this {
         check32Bit(locktime);
         checkInputsForPartialSig(this.data.inputs, 'setLocktime');
         const c = this.__CACHE;
@@ -182,7 +256,8 @@ class Psbt {
         c.__EXTRACTED_TX = undefined;
         return this;
     }
-    setInputSequence(inputIndex, sequence) {
+
+    setInputSequence(inputIndex: number, sequence: number): this {
         check32Bit(sequence);
         checkInputsForPartialSig(this.data.inputs, 'setInputSequence');
         const c = this.__CACHE;
@@ -193,32 +268,32 @@ class Psbt {
         c.__EXTRACTED_TX = undefined;
         return this;
     }
-    addInputs(inputDatas, checkPartialSigs = true) {
-        inputDatas.forEach(inputData =>
-            this.addInput(inputData, checkPartialSigs),
-        );
+
+    addInputs(inputDatas: PsbtInputExtended[], checkPartialSigs: boolean = true): this {
+        inputDatas.forEach((inputData) => this.addInput(inputData, checkPartialSigs));
         return this;
     }
-    addInput(inputData, checkPartialSigs = true) {
-        if (
-            !inputData ||
-            inputData.hash === undefined ||
-            inputData.index === undefined
-        ) {
+
+    addInput(inputData: PsbtInputExtended, checkPartialSigs: boolean = true): this {
+        if (!inputData || inputData.hash === undefined || inputData.index === undefined) {
             throw new Error(
                 `Invalid arguments for Psbt.addInput. ` +
                     `Requires single object with at least [hash] and [index]`,
             );
         }
-        (0, bip371_1.checkTaprootInputFields)(inputData, inputData, 'addInput');
+
+        checkTaprootInputFields(inputData, inputData, 'addInput');
+
         if (checkPartialSigs) {
             checkInputsForPartialSig(this.data.inputs, 'addInput');
         }
+
         if (inputData.witnessScript) checkInvalidP2WSH(inputData.witnessScript);
         const c = this.__CACHE;
         this.data.addInput(inputData);
         const txIn = c.__TX.ins[c.__TX.ins.length - 1];
         checkTxInputCache(c, txIn);
+
         const inputIndex = this.data.inputs.length - 1;
         const input = this.data.inputs[inputIndex];
         if (input.nonWitnessUtxo) {
@@ -229,17 +304,18 @@ class Psbt {
         c.__EXTRACTED_TX = undefined;
         return this;
     }
-    addOutputs(outputDatas) {
-        outputDatas.forEach(outputData => this.addOutput(outputData));
+
+    addOutputs(outputDatas: PsbtOutputExtended[]): this {
+        outputDatas.forEach((outputData) => this.addOutput(outputData));
         return this;
     }
-    addOutput(outputData) {
+
+    addOutput(outputData: PsbtOutputExtended): this {
         if (
             arguments.length > 1 ||
             !outputData ||
             outputData.value === undefined ||
-            (outputData.address === undefined &&
-                outputData.script === undefined)
+            ((outputData as any).address === undefined && (outputData as any).script === undefined)
         ) {
             throw new Error(
                 `Invalid arguments for Psbt.addOutput. ` +
@@ -247,17 +323,14 @@ class Psbt {
             );
         }
         checkInputsForPartialSig(this.data.inputs, 'addOutput');
-        const { address } = outputData;
+        const { address } = outputData as any;
         if (typeof address === 'string') {
             const { network } = this.opts;
-            const script = (0, address_1.toOutputScript)(address, network);
+            const script = toOutputScript(address, network);
             outputData = Object.assign({}, outputData, { script });
         }
-        (0, bip371_1.checkTaprootOutputFields)(
-            outputData,
-            outputData,
-            'addOutput',
-        );
+        checkTaprootOutputFields(outputData, outputData, 'addOutput');
+
         const c = this.__CACHE;
         this.data.addOutput(outputData);
         c.__FEE = undefined;
@@ -265,68 +338,71 @@ class Psbt {
         c.__EXTRACTED_TX = undefined;
         return this;
     }
-    extractTransaction(disableFeeCheck, disableOutputChecks) {
+
+    extractTransaction(disableFeeCheck?: boolean, disableOutputChecks?: boolean): Transaction {
         if (disableOutputChecks) {
-            this.data.inputs = this.data.inputs.filter(i => !i.partialSig);
+            this.data.inputs = this.data.inputs.filter((i) => !i.partialSig);
         }
-        if (!this.data.inputs.every(isFinalized))
-            throw new Error('Not finalized');
+
+        if (!this.data.inputs.every(isFinalized)) throw new Error('Not finalized');
         const c = this.__CACHE;
         if (!disableFeeCheck) {
             checkFees(this, c, this.opts);
         }
         if (c.__EXTRACTED_TX) return c.__EXTRACTED_TX;
         const tx = c.__TX.clone();
-        inputFinalizeGetAmts(
-            this.data.inputs,
-            tx,
-            c,
-            true,
-            disableOutputChecks,
-        );
+        inputFinalizeGetAmts(this.data.inputs, tx, c, true, disableOutputChecks);
         return tx;
     }
-    getFeeRate(disableOutputChecks = false) {
+
+    getFeeRate(disableOutputChecks: boolean = false): number {
         return getTxCacheValue(
             '__FEE_RATE',
             'fee rate',
             this.data.inputs,
             this.__CACHE,
             disableOutputChecks,
-        );
+        )!;
     }
-    getFee(disableOutputChecks = false) {
+
+    getFee(disableOutputChecks: boolean = false): number {
         return getTxCacheValue(
             '__FEE',
             'fee',
             this.data.inputs,
             this.__CACHE,
             disableOutputChecks,
-        );
+        )!;
     }
-    finalizeAllInputs() {
-        (0, utils_1.checkForInput)(this.data.inputs, 0); // making sure we have at least one
-        range(this.data.inputs.length).forEach(idx => this.finalizeInput(idx));
+
+    finalizeAllInputs(): this {
+        checkForInput(this.data.inputs, 0); // making sure we have at least one
+        range(this.data.inputs.length).forEach((idx) => this.finalizeInput(idx));
         return this;
     }
-    finalizeInput(inputIndex, finalScriptsFunc) {
-        const input = (0, utils_1.checkForInput)(this.data.inputs, inputIndex);
-        if ((0, bip371_1.isTaprootInput)(input))
+
+    finalizeInput(
+        inputIndex: number,
+        finalScriptsFunc?: FinalScriptsFunc | FinalTaprootScriptsFunc,
+    ): this {
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input))
             return this._finalizeTaprootInput(
                 inputIndex,
                 input,
                 undefined,
-                finalScriptsFunc,
+                finalScriptsFunc as FinalTaprootScriptsFunc,
             );
-        return this._finalizeInput(inputIndex, input, finalScriptsFunc);
+        return this._finalizeInput(inputIndex, input, finalScriptsFunc as FinalScriptsFunc);
     }
+
     finalizeTaprootInput(
-        inputIndex,
-        tapLeafHashToFinalize,
-        finalScriptsFunc = bip371_1.tapScriptFinalizer,
-    ) {
-        const input = (0, utils_1.checkForInput)(this.data.inputs, inputIndex);
-        if ((0, bip371_1.isTaprootInput)(input))
+        inputIndex: number,
+        tapLeafHashToFinalize?: Buffer,
+        finalScriptsFunc: FinalTaprootScriptsFunc = tapScriptFinalizer,
+    ): this {
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input))
             return this._finalizeTaprootInput(
                 inputIndex,
                 input,
@@ -335,77 +411,70 @@ class Psbt {
             );
         throw new Error(`Cannot finalize input #${inputIndex}. Not Taproot.`);
     }
-    getInputType(inputIndex) {
-        const input = (0, utils_1.checkForInput)(this.data.inputs, inputIndex);
+
+    getInputType(inputIndex: number): AllScriptType {
+        const input = checkForInput(this.data.inputs, inputIndex);
         const script = getScriptFromUtxo(inputIndex, input, this.__CACHE);
         const result = getMeaningfulScript(
             script,
             inputIndex,
             'input',
-            input.redeemScript ||
-                redeemFromFinalScriptSig(input.finalScriptSig),
-            input.witnessScript ||
-                redeemFromFinalWitnessScript(input.finalScriptWitness),
+            input.redeemScript || redeemFromFinalScriptSig(input.finalScriptSig),
+            input.witnessScript || redeemFromFinalWitnessScript(input.finalScriptWitness),
         );
         const type = result.type === 'raw' ? '' : result.type + '-';
         const mainType = classifyScript(result.meaningfulScript);
-        return type + mainType;
+        return (type + mainType) as AllScriptType;
     }
-    inputHasPubkey(inputIndex, pubkey) {
-        const input = (0, utils_1.checkForInput)(this.data.inputs, inputIndex);
+
+    inputHasPubkey(inputIndex: number, pubkey: Buffer): boolean {
+        const input = checkForInput(this.data.inputs, inputIndex);
         return pubkeyInInput(pubkey, input, inputIndex, this.__CACHE);
     }
-    inputHasHDKey(inputIndex, root) {
-        const input = (0, utils_1.checkForInput)(this.data.inputs, inputIndex);
+
+    inputHasHDKey(inputIndex: number, root: HDSigner): boolean {
+        const input = checkForInput(this.data.inputs, inputIndex);
         const derivationIsMine = bip32DerivationIsMine(root);
-        return (
-            !!input.bip32Derivation &&
-            input.bip32Derivation.some(derivationIsMine)
-        );
+        return !!input.bip32Derivation && input.bip32Derivation.some(derivationIsMine);
     }
-    outputHasPubkey(outputIndex, pubkey) {
-        const output = (0, utils_1.checkForOutput)(
-            this.data.outputs,
-            outputIndex,
-        );
+
+    outputHasPubkey(outputIndex: number, pubkey: Buffer): boolean {
+        const output = checkForOutput(this.data.outputs, outputIndex);
         return pubkeyInOutput(pubkey, output, outputIndex, this.__CACHE);
     }
-    outputHasHDKey(outputIndex, root) {
-        const output = (0, utils_1.checkForOutput)(
-            this.data.outputs,
-            outputIndex,
-        );
+
+    outputHasHDKey(outputIndex: number, root: HDSigner): boolean {
+        const output = checkForOutput(this.data.outputs, outputIndex);
         const derivationIsMine = bip32DerivationIsMine(root);
-        return (
-            !!output.bip32Derivation &&
-            output.bip32Derivation.some(derivationIsMine)
-        );
+        return !!output.bip32Derivation && output.bip32Derivation.some(derivationIsMine);
     }
-    validateSignaturesOfAllInputs(validator) {
-        (0, utils_1.checkForInput)(this.data.inputs, 0); // making sure we have at least one
-        const results = range(this.data.inputs.length).map(idx =>
+
+    validateSignaturesOfAllInputs(validator: ValidateSigFunction): boolean {
+        checkForInput(this.data.inputs, 0); // making sure we have at least one
+        const results = range(this.data.inputs.length).map((idx) =>
             this.validateSignaturesOfInput(idx, validator),
         );
         return results.reduce((final, res) => res === true && final, true);
     }
-    validateSignaturesOfInput(inputIndex, validator, pubkey) {
+
+    validateSignaturesOfInput(
+        inputIndex: number,
+        validator: ValidateSigFunction,
+        pubkey?: Buffer,
+    ): boolean {
         const input = this.data.inputs[inputIndex];
-        if ((0, bip371_1.isTaprootInput)(input))
-            return this.validateSignaturesOfTaprootInput(
-                inputIndex,
-                validator,
-                pubkey,
-            );
+        if (isTaprootInput(input))
+            return this.validateSignaturesOfTaprootInput(inputIndex, validator, pubkey);
+
         return this._validateSignaturesOfInput(inputIndex, validator, pubkey);
     }
-    signAllInputsHD(
-        hdKeyPair,
-        sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
-    ) {
+
+    signAllInputsHD(hdKeyPair: HDSigner, sighashTypes: number[] = [Transaction.SIGHASH_ALL]): this {
         if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
             throw new Error('Need HDSigner to sign input');
         }
-        const results = [];
+
+        const results: boolean[] = [];
         for (const i of range(this.data.inputs.length)) {
             try {
                 this.signInputHD(i, hdKeyPair, sighashTypes);
@@ -414,21 +483,23 @@ class Psbt {
                 results.push(false);
             }
         }
-        if (results.every(v => v === false)) {
+        if (results.every((v) => v === false)) {
             throw new Error('No inputs were signed');
         }
         return this;
     }
+
     signAllInputsHDAsync(
-        hdKeyPair,
-        sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
-    ) {
-        return new Promise((resolve, reject) => {
+        hdKeyPair: HDSigner | HDSignerAsync,
+        sighashTypes: number[] = [Transaction.SIGHASH_ALL],
+    ): Promise<void> {
+        return new Promise((resolve, reject): any => {
             if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
                 return reject(new Error('Need HDSigner to sign input'));
             }
-            const results = [];
-            const promises = [];
+
+            const results: boolean[] = [];
+            const promises: Array<Promise<void>> = [];
             for (const i of range(this.data.inputs.length)) {
                 promises.push(
                     this.signInputHDAsync(i, hdKeyPair, sighashTypes).then(
@@ -442,47 +513,39 @@ class Psbt {
                 );
             }
             return Promise.all(promises).then(() => {
-                if (results.every(v => v === false)) {
+                if (results.every((v) => v === false)) {
                     return reject(new Error('No inputs were signed'));
                 }
                 resolve();
             });
         });
     }
+
     signInputHD(
-        inputIndex,
-        hdKeyPair,
-        sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
-    ) {
+        inputIndex: number,
+        hdKeyPair: HDSigner,
+        sighashTypes: number[] = [Transaction.SIGHASH_ALL],
+    ): this {
         if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
             throw new Error('Need HDSigner to sign input');
         }
-        const signers = getSignersFromHD(
-            inputIndex,
-            this.data.inputs,
-            hdKeyPair,
-        );
-        signers.forEach(signer =>
-            this.signInput(inputIndex, signer, sighashTypes),
-        );
+        const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair) as Signer[];
+        signers.forEach((signer) => this.signInput(inputIndex, signer, sighashTypes));
         return this;
     }
+
     signInputHDAsync(
-        inputIndex,
-        hdKeyPair,
-        sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
-    ) {
-        return new Promise((resolve, reject) => {
+        inputIndex: number,
+        hdKeyPair: HDSigner | HDSignerAsync,
+        sighashTypes: number[] = [Transaction.SIGHASH_ALL],
+    ): Promise<void> {
+        return new Promise((resolve, reject): any => {
             if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
                 return reject(new Error('Need HDSigner to sign input'));
             }
-            const signers = getSignersFromHD(
-                inputIndex,
-                this.data.inputs,
-                hdKeyPair,
-            );
-            const promises = signers.map(signer =>
-                this.signInputAsync(inputIndex, signer, sighashTypes),
+            const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);
+            const promises = signers.map((signer) =>
+                this.signInputAsync(inputIndex, signer as unknown as Signer, sighashTypes),
             );
             return Promise.all(promises)
                 .then(() => {
@@ -491,13 +554,17 @@ class Psbt {
                 .catch(reject);
         });
     }
-    signAllInputs(keyPair, sighashTypes) {
-        if (!keyPair || !keyPair.publicKey)
-            throw new Error('Need Signer to sign input');
+
+    signAllInputs(
+        keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface,
+        sighashTypes?: number[],
+    ): this {
+        if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
+
         // TODO: Add a pubkey/pubkeyhash cache to each input
         // as input information is added, then eventually
         // optimize this method.
-        const results = [];
+        const results: boolean[] = [];
         for (const i of range(this.data.inputs.length)) {
             try {
                 this.signInput(i, keyPair, sighashTypes);
@@ -506,20 +573,25 @@ class Psbt {
                 results.push(false);
             }
         }
-        if (results.every(v => v === false)) {
+        if (results.every((v) => v === false)) {
             throw new Error('No inputs were signed');
         }
         return this;
     }
-    signAllInputsAsync(keyPair, sighashTypes) {
-        return new Promise((resolve, reject) => {
+
+    signAllInputsAsync(
+        keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
+        sighashTypes?: number[],
+    ): Promise<void> {
+        return new Promise((resolve, reject): any => {
             if (!keyPair || !keyPair.publicKey)
                 return reject(new Error('Need Signer to sign input'));
+
             // TODO: Add a pubkey/pubkeyhash cache to each input
             // as input information is added, then eventually
             // optimize this method.
-            const results = [];
-            const promises = [];
+            const results: boolean[] = [];
+            const promises: Array<Promise<void>> = [];
             for (const [i] of this.data.inputs.entries()) {
                 promises.push(
                     this.signInputAsync(i, keyPair, sighashTypes).then(
@@ -533,33 +605,43 @@ class Psbt {
                 );
             }
             return Promise.all(promises).then(() => {
-                if (results.every(v => v === false)) {
+                if (results.every((v) => v === false)) {
                     return reject(new Error('No inputs were signed'));
                 }
                 resolve();
             });
         });
     }
-    signInput(inputIndex, keyPair, sighashTypes) {
-        if (!keyPair || !keyPair.publicKey)
+
+    signInput(
+        inputIndex: number,
+        keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface,
+        sighashTypes?: number[],
+    ): this {
+        if (!keyPair || !keyPair.publicKey) {
             throw new Error('Need Signer to sign input');
-        const input = (0, utils_1.checkForInput)(this.data.inputs, inputIndex);
-        if ((0, bip371_1.isTaprootInput)(input)) {
-            return this._signTaprootInput(
-                inputIndex,
-                input,
-                keyPair,
-                undefined,
-                sighashTypes,
-            );
         }
+
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input)) {
+            return this._signTaprootInput(inputIndex, input, keyPair, undefined, sighashTypes);
+        }
+
         return this._signInput(inputIndex, keyPair, sighashTypes);
     }
-    signTaprootInput(inputIndex, keyPair, tapLeafHashToSign, sighashTypes) {
-        if (!keyPair || !keyPair.publicKey)
+
+    signTaprootInput(
+        inputIndex: number,
+        keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface,
+        tapLeafHashToSign?: Buffer,
+        sighashTypes?: number[],
+    ): this {
+        if (!keyPair || !keyPair.publicKey) {
             throw new Error('Need Signer to sign input');
-        const input = (0, utils_1.checkForInput)(this.data.inputs, inputIndex);
-        if ((0, bip371_1.isTaprootInput)(input))
+        }
+
+        const input = checkForInput(this.data.inputs, inputIndex);
+        if (isTaprootInput(input)) {
             return this._signTaprootInput(
                 inputIndex,
                 input,
@@ -567,17 +649,21 @@ class Psbt {
                 tapLeafHashToSign,
                 sighashTypes,
             );
+        }
+
         throw new Error(`Input #${inputIndex} is not of type Taproot.`);
     }
-    signInputAsync(inputIndex, keyPair, sighashTypes) {
+
+    signInputAsync(
+        inputIndex: number,
+        keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
+        sighashTypes?: number[],
+    ): Promise<void> {
         return Promise.resolve().then(() => {
-            if (!keyPair || !keyPair.publicKey)
-                throw new Error('Need Signer to sign input');
-            const input = (0, utils_1.checkForInput)(
-                this.data.inputs,
-                inputIndex,
-            );
-            if ((0, bip371_1.isTaprootInput)(input))
+            if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
+
+            const input = checkForInput(this.data.inputs, inputIndex);
+            if (isTaprootInput(input))
                 return this._signTaprootInputAsync(
                     inputIndex,
                     input,
@@ -585,18 +671,22 @@ class Psbt {
                     undefined,
                     sighashTypes,
                 );
+
             return this._signInputAsync(inputIndex, keyPair, sighashTypes);
         });
     }
-    signTaprootInputAsync(inputIndex, keyPair, tapLeafHash, sighashTypes) {
+
+    signTaprootInputAsync(
+        inputIndex: number,
+        keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
+        tapLeafHash?: Buffer,
+        sighashTypes?: number[],
+    ): Promise<void> {
         return Promise.resolve().then(() => {
-            if (!keyPair || !keyPair.publicKey)
-                throw new Error('Need Signer to sign input');
-            const input = (0, utils_1.checkForInput)(
-                this.data.inputs,
-                inputIndex,
-            );
-            if ((0, bip371_1.isTaprootInput)(input))
+            if (!keyPair || !keyPair.publicKey) throw new Error('Need Signer to sign input');
+
+            const input = checkForInput(this.data.inputs, inputIndex);
+            if (isTaprootInput(input))
                 return this._signTaprootInputAsync(
                     inputIndex,
                     input,
@@ -604,78 +694,113 @@ class Psbt {
                     tapLeafHash,
                     sighashTypes,
                 );
+
             throw new Error(`Input #${inputIndex} is not of type Taproot.`);
         });
     }
-    toBuffer() {
+
+    toBuffer(): Buffer {
         checkCache(this.__CACHE);
         return this.data.toBuffer();
     }
-    toHex() {
+
+    toHex(): string {
         checkCache(this.__CACHE);
         return this.data.toHex();
     }
-    toBase64() {
+
+    toBase64(): string {
         checkCache(this.__CACHE);
         return this.data.toBase64();
     }
-    updateGlobal(updateData) {
+
+    updateGlobal(updateData: PsbtGlobalUpdate): this {
         this.data.updateGlobal(updateData);
         return this;
     }
-    updateInput(inputIndex, updateData) {
-        if (updateData.witnessScript)
-            checkInvalidP2WSH(updateData.witnessScript);
-        (0, bip371_1.checkTaprootInputFields)(
-            this.data.inputs[inputIndex],
-            updateData,
-            'updateInput',
-        );
+
+    updateInput(inputIndex: number, updateData: PsbtInputUpdate): this {
+        if (updateData.witnessScript) checkInvalidP2WSH(updateData.witnessScript);
+        checkTaprootInputFields(this.data.inputs[inputIndex], updateData, 'updateInput');
         this.data.updateInput(inputIndex, updateData);
         if (updateData.nonWitnessUtxo) {
-            addNonWitnessTxCache(
-                this.__CACHE,
-                this.data.inputs[inputIndex],
-                inputIndex,
-            );
+            addNonWitnessTxCache(this.__CACHE, this.data.inputs[inputIndex], inputIndex);
         }
         return this;
     }
-    updateOutput(outputIndex, updateData) {
+
+    updateOutput(outputIndex: number, updateData: PsbtOutputUpdate): this {
         const outputData = this.data.outputs[outputIndex];
-        (0, bip371_1.checkTaprootOutputFields)(
-            outputData,
-            updateData,
-            'updateOutput',
-        );
+        checkTaprootOutputFields(outputData, updateData, 'updateOutput');
+
         this.data.updateOutput(outputIndex, updateData);
         return this;
     }
-    addUnknownKeyValToGlobal(keyVal) {
+
+    addUnknownKeyValToGlobal(keyVal: KeyValue): this {
         this.data.addUnknownKeyValToGlobal(keyVal);
         return this;
     }
-    addUnknownKeyValToInput(inputIndex, keyVal) {
+
+    addUnknownKeyValToInput(inputIndex: number, keyVal: KeyValue): this {
         this.data.addUnknownKeyValToInput(inputIndex, keyVal);
         return this;
     }
-    addUnknownKeyValToOutput(outputIndex, keyVal) {
+
+    addUnknownKeyValToOutput(outputIndex: number, keyVal: KeyValue): this {
         this.data.addUnknownKeyValToOutput(outputIndex, keyVal);
         return this;
     }
-    clearFinalizedInput(inputIndex) {
+
+    clearFinalizedInput(inputIndex: number): this {
         this.data.clearFinalizedInput(inputIndex);
         return this;
     }
-    _finalizeInput(inputIndex, input, finalScriptsFunc = getFinalScripts) {
+
+    public checkTaprootHashesForSig(
+        inputIndex: number,
+        input: PsbtInput,
+        keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
+        tapLeafHashToSign?: Buffer,
+        allowedSighashTypes?: number[],
+    ): { hash: Buffer; leafHash?: Buffer }[] {
+        if (typeof keyPair.signSchnorr !== 'function')
+            throw new Error(`Need Schnorr Signer to sign taproot input #${inputIndex}.`);
+
+        const hashesForSig = getTaprootHashesForSig(
+            inputIndex,
+            input,
+            this.data.inputs,
+            keyPair.publicKey,
+            this.__CACHE,
+            tapLeafHashToSign,
+            allowedSighashTypes,
+        );
+
+        if (!hashesForSig || !hashesForSig.length)
+            throw new Error(
+                `Can not sign for input #${inputIndex} with the key ${keyPair.publicKey.toString(
+                    'hex',
+                )}`,
+            );
+
+        return hashesForSig;
+    }
+
+    private _finalizeInput(
+        inputIndex: number,
+        input: PsbtInput,
+        finalScriptsFunc: FinalScriptsFunc = getFinalScripts,
+    ): this {
         const { script, isP2SH, isP2WSH, isSegwit } = getScriptFromInput(
             inputIndex,
             input,
             this.__CACHE,
         );
-        if (!script)
-            throw new Error(`No script found for input #${inputIndex}`);
+        if (!script) throw new Error(`No script found for input #${inputIndex}`);
+
         checkPartialSigSighashes(input);
+
         const { finalScriptSig, finalScriptWitness } = finalScriptsFunc(
             inputIndex,
             input,
@@ -684,33 +809,32 @@ class Psbt {
             isP2SH,
             isP2WSH,
         );
-        if (finalScriptSig)
-            this.data.updateInput(inputIndex, { finalScriptSig });
-        if (finalScriptWitness)
-            this.data.updateInput(inputIndex, { finalScriptWitness });
+
+        if (finalScriptSig) this.data.updateInput(inputIndex, { finalScriptSig });
+        if (finalScriptWitness) this.data.updateInput(inputIndex, { finalScriptWitness });
         if (!finalScriptSig && !finalScriptWitness)
             throw new Error(`Unknown error finalizing input #${inputIndex}`);
+
         this.data.clearFinalizedInput(inputIndex);
         return this;
     }
-    _finalizeTaprootInput(
-        inputIndex,
-        input,
-        tapLeafHashToFinalize,
-        finalScriptsFunc = bip371_1.tapScriptFinalizer,
-    ) {
+
+    private _finalizeTaprootInput(
+        inputIndex: number,
+        input: PsbtInput,
+        tapLeafHashToFinalize?: Buffer,
+        finalScriptsFunc = tapScriptFinalizer,
+    ): this {
         if (!input.witnessUtxo)
-            throw new Error(
-                `Cannot finalize input #${inputIndex}. Missing withness utxo.`,
-            );
+            throw new Error(`Cannot finalize input #${inputIndex}. Missing witness utxo.`);
+
         // Check key spend first. Increased privacy and reduced block space.
         if (input.tapKeySig) {
             const payment = payments.p2tr({
                 output: input.witnessUtxo.script,
                 signature: input.tapKeySig,
             });
-            const finalScriptWitness = (0,
-            psbtutils_1.witnessStackToScriptWitness)(payment.witness);
+            const finalScriptWitness = witnessStackToScriptWitness(payment.witness!);
             this.data.updateInput(inputIndex, { finalScriptWitness });
         } else {
             const { finalScriptWitness } = finalScriptsFunc(
@@ -720,28 +844,33 @@ class Psbt {
             );
             this.data.updateInput(inputIndex, { finalScriptWitness });
         }
+
         this.data.clearFinalizedInput(inputIndex);
+
         return this;
     }
-    _validateSignaturesOfInput(inputIndex, validator, pubkey) {
+
+    private _validateSignaturesOfInput(
+        inputIndex: number,
+        validator: ValidateSigFunction,
+        pubkey?: Buffer,
+    ): boolean {
         const input = this.data.inputs[inputIndex];
         const partialSig = (input || {}).partialSig;
         if (!input || !partialSig || partialSig.length < 1)
             throw new Error('No signatures to validate');
         if (typeof validator !== 'function')
             throw new Error('Need validator function to validate signatures');
-        const mySigs = pubkey
-            ? partialSig.filter(sig => sig.pubkey.equals(pubkey))
-            : partialSig;
+        const mySigs = pubkey ? partialSig.filter((sig) => sig.pubkey.equals(pubkey)) : partialSig;
         if (mySigs.length < 1) throw new Error('No signatures for this pubkey');
-        const results = [];
-        let hashCache;
-        let scriptCache;
-        let sighashCache;
+        const results: boolean[] = [];
+        let hashCache: Buffer;
+        let scriptCache: Buffer;
+        let sighashCache: number;
         for (const pSig of mySigs) {
             const sig = bscript.signature.decode(pSig.signature);
             const { hash, script } =
-                sighashCache !== sig.hashType
+                sighashCache! !== sig.hashType
                     ? getHashForSig(
                           inputIndex,
                           Object.assign({}, input, {
@@ -750,16 +879,21 @@ class Psbt {
                           this.__CACHE,
                           true,
                       )
-                    : { hash: hashCache, script: scriptCache };
+                    : { hash: hashCache!, script: scriptCache! };
             sighashCache = sig.hashType;
             hashCache = hash;
             scriptCache = script;
             checkScriptForPubkey(pSig.pubkey, script, 'verify');
             results.push(validator(pSig.pubkey, hash, sig.signature));
         }
-        return results.every(res => res === true);
-    }
-    validateSignaturesOfTaprootInput(inputIndex, validator, pubkey) {
+        return results.every((res) => res === true);
+    }
+
+    private validateSignaturesOfTaprootInput(
+        inputIndex: number,
+        validator: ValidateSigFunction,
+        pubkey?: Buffer,
+    ): boolean {
         const input = this.data.inputs[inputIndex];
         const tapKeySig = (input || {}).tapKeySig;
         const tapScriptSig = (input || {}).tapScriptSig;
@@ -767,24 +901,15 @@ class Psbt {
             throw new Error('No signatures to validate');
         if (typeof validator !== 'function')
             throw new Error('Need validator function to validate signatures');
-        pubkey = pubkey && (0, bip371_1.toXOnly)(pubkey);
+
+        pubkey = pubkey && toXOnly(pubkey);
         const allHashses = pubkey
-            ? getTaprootHashesForSig(
-                  inputIndex,
-                  input,
-                  this.data.inputs,
-                  pubkey,
-                  this.__CACHE,
-              )
-            : getAllTaprootHashesForSig(
-                  inputIndex,
-                  input,
-                  this.data.inputs,
-                  this.__CACHE,
-              );
-        if (!allHashses.length)
-            throw new Error('No signatures for this pubkey');
-        const tapKeyHash = allHashses.find(h => !h.leafHash);
+            ? getTaprootHashesForSig(inputIndex, input, this.data.inputs, pubkey, this.__CACHE)
+            : getAllTaprootHashesForSig(inputIndex, input, this.data.inputs, this.__CACHE);
+
+        if (!allHashses.length) throw new Error('No signatures for this pubkey');
+
+        const tapKeyHash = allHashses.find((h) => !h.leafHash);
         let validationResultCount = 0;
         if (tapKeySig && tapKeyHash) {
             const isValidTapkeySig = validator(
@@ -795,11 +920,10 @@ class Psbt {
             if (!isValidTapkeySig) return false;
             validationResultCount++;
         }
+
         if (tapScriptSig) {
             for (const tapSig of tapScriptSig) {
-                const tapSigHash = allHashses.find(h =>
-                    tapSig.pubkey.equals(h.pubkey),
-                );
+                const tapSigHash = allHashses.find((h) => tapSig.pubkey.equals(h.pubkey));
                 if (tapSigHash) {
                     const isValidTapScriptSig = validator(
                         tapSig.pubkey,
@@ -811,14 +935,17 @@ class Psbt {
                 }
             }
         }
+
         return validationResultCount > 0;
     }
-    _signInput(
-        inputIndex,
-        keyPair,
-        sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
-    ) {
-        (0, HookedSigner_js_1.hookSigner)(keyPair);
+
+    private _signInput(
+        inputIndex: number,
+        keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface,
+        sighashTypes: number[] = [Transaction.SIGHASH_ALL],
+    ): this {
+        hookSigner(keyPair);
+
         const { hash, sighashType } = getHashAndSighashType(
             this.data.inputs,
             inputIndex,
@@ -826,26 +953,27 @@ class Psbt {
             this.__CACHE,
             sighashTypes,
         );
+
         const partialSig = [
             {
                 pubkey: keyPair.publicKey,
-                signature: bscript.signature.encode(
-                    keyPair.sign(hash),
-                    sighashType,
-                ),
+                signature: bscript.signature.encode(keyPair.sign(hash), sighashType),
             },
         ];
+
         this.data.updateInput(inputIndex, { partialSig });
         return this;
     }
-    _signTaprootInput(
-        inputIndex,
-        input,
-        keyPair,
-        tapLeafHashToSign,
-        allowedSighashTypes = [transaction_1.Transaction.SIGHASH_DEFAULT],
-    ) {
-        (0, HookedSigner_js_1.hookSigner)(keyPair);
+
+    private _signTaprootInput(
+        inputIndex: number,
+        input: PsbtInput,
+        keyPair: Signer | SignerAlternative | BIP32Interface | ECPairInterface,
+        tapLeafHashToSign?: Buffer,
+        allowedSighashTypes: number[] = [Transaction.SIGHASH_DEFAULT],
+    ): this {
+        hookSigner(keyPair);
+
         const hashesForSig = this.checkTaprootHashesForSig(
             inputIndex,
             input,
@@ -853,38 +981,45 @@ class Psbt {
             tapLeafHashToSign,
             allowedSighashTypes,
         );
-        const tapKeySig = hashesForSig
-            .filter(h => !h.leafHash)
-            .map(h =>
-                (0, bip371_1.serializeTaprootSignature)(
-                    keyPair.signSchnorr(h.hash),
-                    input.sighashType,
-                ),
+
+        const tapKeySig: TapKeySig = hashesForSig
+            .filter((h) => !h.leafHash)
+            .map((h) =>
+                serializeTaprootSignature(keyPair.signSchnorr!(h.hash), input.sighashType),
             )[0];
-        const tapScriptSig = hashesForSig
-            .filter(h => !!h.leafHash)
-            .map(h => ({
-                pubkey: (0, bip371_1.toXOnly)(keyPair.publicKey),
-                signature: (0, bip371_1.serializeTaprootSignature)(
-                    keyPair.signSchnorr(h.hash),
-                    input.sighashType,
-                ),
-                leafHash: h.leafHash,
-            }));
+
+        const tapScriptSig: TapScriptSig[] = hashesForSig
+            .filter((h) => !!h.leafHash)
+            .map(
+                (h) =>
+                    ({
+                        pubkey: toXOnly(keyPair.publicKey),
+                        signature: serializeTaprootSignature(
+                            keyPair.signSchnorr!(h.hash),
+                            input.sighashType,
+                        ),
+                        leafHash: h.leafHash,
+                    }) as TapScriptSig,
+            );
+
         if (tapKeySig) {
             this.data.updateInput(inputIndex, { tapKeySig });
         }
+
         if (tapScriptSig.length) {
             this.data.updateInput(inputIndex, { tapScriptSig });
         }
+
         return this;
     }
-    _signInputAsync(
-        inputIndex,
-        keyPair,
-        sighashTypes = [transaction_1.Transaction.SIGHASH_ALL],
-    ) {
-        (0, HookedSigner_js_1.hookSigner)(keyPair);
+
+    private _signInputAsync(
+        inputIndex: number,
+        keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
+        sighashTypes: number[] = [Transaction.SIGHASH_ALL],
+    ): Promise<void> {
+        hookSigner(keyPair);
+
         const { hash, sighashType } = getHashAndSighashType(
             this.data.inputs,
             inputIndex,
@@ -892,24 +1027,28 @@ class Psbt {
             this.__CACHE,
             sighashTypes,
         );
-        return Promise.resolve(keyPair.sign(hash)).then(signature => {
+
+        return Promise.resolve(keyPair.sign(hash)).then((signature) => {
             const partialSig = [
                 {
                     pubkey: keyPair.publicKey,
                     signature: bscript.signature.encode(signature, sighashType),
                 },
             ];
+
             this.data.updateInput(inputIndex, { partialSig });
         });
     }
-    async _signTaprootInputAsync(
-        inputIndex,
-        input,
-        keyPair,
-        tapLeafHash,
-        sighashTypes = [transaction_1.Transaction.SIGHASH_DEFAULT],
-    ) {
-        (0, HookedSigner_js_1.hookSigner)(keyPair);
+
+    private async _signTaprootInputAsync(
+        inputIndex: number,
+        input: PsbtInput,
+        keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface,
+        tapLeafHash?: Buffer,
+        sighashTypes: number[] = [Transaction.SIGHASH_DEFAULT],
+    ): Promise<void> {
+        hookSigner(keyPair);
+
         const hashesForSig = this.checkTaprootHashesForSig(
             inputIndex,
             input,
@@ -917,101 +1056,187 @@ class Psbt {
             tapLeafHash,
             sighashTypes,
         );
-        const signaturePromises = [];
-        const tapKeyHash = hashesForSig.filter(h => !h.leafHash)[0];
+
+        const signaturePromises: Promise<
+            { tapKeySig: Buffer } | { tapScriptSig: TapScriptSig[] }
+        >[] = [];
+
+        const tapKeyHash = hashesForSig.filter((h) => !h.leafHash)[0];
         if (tapKeyHash) {
-            const tapKeySigPromise = Promise.resolve(
-                keyPair.signSchnorr(tapKeyHash.hash),
-            ).then(sig => {
-                return {
-                    tapKeySig: (0, bip371_1.serializeTaprootSignature)(
-                        sig,
-                        input.sighashType,
-                    ),
-                };
-            });
+            const tapKeySigPromise = Promise.resolve(keyPair.signSchnorr!(tapKeyHash.hash)).then(
+                (sig) => {
+                    return {
+                        tapKeySig: serializeTaprootSignature(sig, input.sighashType),
+                    };
+                },
+            );
             signaturePromises.push(tapKeySigPromise);
         }
-        const tapScriptHashes = hashesForSig.filter(h => !!h.leafHash);
+
+        const tapScriptHashes = hashesForSig.filter((h) => !!h.leafHash);
         if (tapScriptHashes.length) {
-            const tapScriptSigPromises = tapScriptHashes.map(async tsh => {
-                const signature = await keyPair.signSchnorr(tsh.hash);
+            const tapScriptSigPromises = tapScriptHashes.map(async (tsh) => {
+                const signature = await keyPair.signSchnorr!(tsh.hash);
+
                 const tapScriptSig = [
                     {
-                        pubkey: (0, bip371_1.toXOnly)(keyPair.publicKey),
-                        signature: (0, bip371_1.serializeTaprootSignature)(
-                            signature,
-                            input.sighashType,
-                        ),
+                        pubkey: toXOnly(keyPair.publicKey),
+                        signature: serializeTaprootSignature(signature, input.sighashType),
                         leafHash: tsh.leafHash,
-                    },
+                    } as TapScriptSig,
                 ];
+
                 return { tapScriptSig };
             });
             signaturePromises.push(...tapScriptSigPromises);
         }
+
         const results = await Promise.all(signaturePromises);
         for (const v of results) {
             this.data.updateInput(inputIndex, v);
         }
     }
-    checkTaprootHashesForSig(
-        inputIndex,
-        input,
-        keyPair,
-        tapLeafHashToSign,
-        allowedSighashTypes,
-    ) {
-        if (typeof keyPair.signSchnorr !== 'function')
-            throw new Error(
-                `Need Schnorr Signer to sign taproot input #${inputIndex}.`,
-            );
-        const hashesForSig = getTaprootHashesForSig(
-            inputIndex,
-            input,
-            this.data.inputs,
-            keyPair.publicKey,
-            this.__CACHE,
-            tapLeafHashToSign,
-            allowedSighashTypes,
-        );
-        if (!hashesForSig || !hashesForSig.length)
-            throw new Error(
-                `Can not sign for input #${inputIndex} with the key ${keyPair.publicKey.toString(
-                    'hex',
-                )}`,
-            );
-        return hashesForSig;
-    }
 }
-exports.Psbt = Psbt;
+
+interface PsbtCache {
+    __NON_WITNESS_UTXO_TX_CACHE: Transaction[];
+    __NON_WITNESS_UTXO_BUF_CACHE: Buffer[];
+    __TX_IN_CACHE: { [index: string]: number };
+    __TX: Transaction;
+    __FEE_RATE?: number;
+    __FEE?: number;
+    __EXTRACTED_TX?: Transaction;
+    __UNSAFE_SIGN_NONSEGWIT: boolean;
+}
+
+export interface PsbtOptsOptional {
+    network?: Network;
+    maximumFeeRate?: number;
+}
+
+export interface PsbtOpts {
+    network: Network;
+    maximumFeeRate: number;
+}
+
+export interface PsbtInputExtended extends PsbtInput, TransactionInput {}
+
+export type PsbtOutputExtended = PsbtOutputExtendedAddress | PsbtOutputExtendedScript;
+
+export interface PsbtOutputExtendedAddress extends PsbtOutput {
+    address: string;
+    value: number;
+}
+
+export interface PsbtOutputExtendedScript extends PsbtOutput {
+    script: Buffer;
+    value: number;
+}
+
+interface HDSignerBase {
+    /**
+     * DER format compressed publicKey buffer
+     */
+    publicKey: Buffer;
+    /**
+     * The first 4 bytes of the sha256-ripemd160 of the publicKey
+     */
+    fingerprint: Buffer;
+}
+
+export interface HDSigner extends HDSignerBase {
+    /**
+     * The path string must match /^m(\/\d+'?)+$/
+     * ex. m/44'/0'/0'/1/23 levels with ' must be hard derivations
+     */
+    derivePath(path: string): HDSigner;
+
+    /**
+     * Input hash (the "message digest") for the signature algorithm
+     * Return a 64 byte signature (32 byte r and 32 byte s in that order)
+     */
+    sign(hash: Buffer): Buffer;
+}
+
+/**
+ * Same as above but with async sign method
+ */
+export interface HDSignerAsync extends HDSignerBase {
+    derivePath(path: string): HDSignerAsync;
+
+    sign(hash: Buffer): Promise<Buffer>;
+}
+
+export interface SignerAlternative {
+    publicKey: Buffer;
+    lowR: boolean;
+
+    sign(hash: Buffer, lowR?: boolean): Buffer;
+
+    verify(hash: Buffer, signature: Buffer): boolean;
+
+    signSchnorr(hash: Buffer): Buffer;
+
+    verifySchnorr(hash: Buffer, signature: Buffer): boolean;
+}
+
+export interface Signer {
+    publicKey: Buffer;
+    network?: Network;
+
+    sign(hash: Buffer, lowR?: boolean): Buffer;
+
+    signSchnorr?(hash: Buffer): Buffer;
+
+    getPublicKey?(): Buffer;
+}
+
+export interface SignerAsync {
+    publicKey: Buffer;
+    network?: Network;
+
+    sign(hash: Buffer, lowR?: boolean): Promise<Buffer>;
+
+    signSchnorr?(hash: Buffer): Promise<Buffer>;
+
+    getPublicKey?(): Buffer;
+}
+
 /**
  * This function is needed to pass to the bip174 base class's fromBuffer.
  * It takes the "transaction buffer" portion of the psbt buffer and returns a
  * Transaction (From the bip174 library) interface.
  */
-const transactionFromBuffer = buffer => new PsbtTransaction(buffer);
+const transactionFromBuffer: TransactionFromBuffer = (buffer: Buffer): ITransaction =>
+    new PsbtTransaction(buffer);
+
 /**
  * This class implements the Transaction interface from bip174 library.
  * It contains a bitcoinjs-lib Transaction object.
  */
-class PsbtTransaction {
-    tx;
-    constructor(buffer = Buffer.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0])) {
-        this.tx = transaction_1.Transaction.fromBuffer(buffer);
+class PsbtTransaction implements ITransaction {
+    tx: Transaction;
+
+    constructor(buffer: Buffer = Buffer.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0])) {
+        this.tx = Transaction.fromBuffer(buffer);
         checkTxEmpty(this.tx);
         Object.defineProperty(this, 'tx', {
             enumerable: false,
             writable: true,
         });
     }
-    getInputOutputCounts() {
+
+    getInputOutputCounts(): {
+        inputCount: number;
+        outputCount: number;
+    } {
         return {
             inputCount: this.tx.ins.length,
             outputCount: this.tx.outs.length,
         };
     }
-    addInput(input) {
+
+    addInput(input: TransactionInput): void {
         if (
             input.hash === undefined ||
             input.index === undefined ||
@@ -1022,13 +1247,13 @@ class PsbtTransaction {
         }
         const hash =
             typeof input.hash === 'string'
-                ? (0, bufferutils_1.reverseBuffer)(
-                      Buffer.from(input.hash, 'hex'),
-                  )
+                ? reverseBuffer(Buffer.from(input.hash, 'hex'))
                 : input.hash;
+
         this.tx.addInput(hash, input.index, input.sequence);
     }
-    addOutput(output) {
+
+    addOutput(output: TransactionOutput): void {
         if (
             output.script === undefined ||
             output.value === undefined ||
@@ -1039,11 +1264,13 @@ class PsbtTransaction {
         }
         this.tx.addOutput(output.script, output.value);
     }
-    toBuffer() {
+
+    toBuffer(): Buffer {
         return this.tx.toBuffer();
     }
 }
-function canFinalize(input, script, scriptType) {
+
+function canFinalize(input: PsbtInput, script: Buffer, scriptType: string): boolean {
     switch (scriptType) {
         case 'pubkey':
         case 'pubkeyhash':
@@ -1051,61 +1278,60 @@ function canFinalize(input, script, scriptType) {
             return hasSigs(1, input.partialSig);
         case 'multisig':
             const p2ms = payments.p2ms({ output: script });
-            return hasSigs(p2ms.m, input.partialSig, p2ms.pubkeys);
+            return hasSigs(p2ms.m!, input.partialSig, p2ms.pubkeys);
         default:
             return false;
     }
 }
-function checkCache(cache) {
+
+function checkCache(cache: PsbtCache): void {
     if (cache.__UNSAFE_SIGN_NONSEGWIT !== false) {
         throw new Error('Not BIP174 compliant, can not export');
     }
 }
-function hasSigs(neededSigs, partialSig, pubkeys) {
+
+function hasSigs(neededSigs: number, partialSig?: any[], pubkeys?: Buffer[]): boolean {
     if (!partialSig) return false;
-    let sigs;
+    let sigs: any;
     if (pubkeys) {
         sigs = pubkeys
-            .map(pkey => {
+            .map((pkey) => {
                 const pubkey = compressPubkey(pkey);
-                return partialSig.find(pSig => pSig.pubkey.equals(pubkey));
+                return partialSig.find((pSig) => pSig.pubkey.equals(pubkey));
             })
-            .filter(v => !!v);
+            .filter((v) => !!v);
     } else {
         sigs = partialSig;
     }
     if (sigs.length > neededSigs) throw new Error('Too many signatures');
     return sigs.length === neededSigs;
 }
-function isFinalized(input) {
+
+function isFinalized(input: PsbtInput): boolean {
     return !!input.finalScriptSig || !!input.finalScriptWitness;
 }
-function bip32DerivationIsMine(root) {
-    return d => {
+
+function bip32DerivationIsMine(root: HDSigner): (d: Bip32Derivation) => boolean {
+    return (d: Bip32Derivation): boolean => {
         if (!d.masterFingerprint.equals(root.fingerprint)) return false;
         if (!root.derivePath(d.path).publicKey.equals(d.pubkey)) return false;
         return true;
     };
 }
-function check32Bit(num) {
-    if (
-        typeof num !== 'number' ||
-        num !== Math.floor(num) ||
-        num > 0xffffffff ||
-        num < 0
-    ) {
+
+function check32Bit(num: number): void {
+    if (typeof num !== 'number' || num !== Math.floor(num) || num > 0xffffffff || num < 0) {
         throw new Error('Invalid 32 bit integer');
     }
 }
-function checkFees(psbt, cache, opts) {
+
+function checkFees(psbt: Psbt, cache: PsbtCache, opts: PsbtOpts): void {
     const feeRate = cache.__FEE_RATE || psbt.getFeeRate();
-    const vsize = cache.__EXTRACTED_TX.virtualSize();
+    const vsize = cache.__EXTRACTED_TX!.virtualSize();
     const satoshis = feeRate * vsize;
     if (feeRate >= opts.maximumFeeRate) {
         throw new Error(
-            `Warning: You are paying around ${(satoshis / 1e8).toFixed(
-                8,
-            )} in ` +
+            `Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` +
                 `fees, which is ${feeRate} satoshi per byte for a transaction ` +
                 `with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` +
                 `byte). Use setMaximumFeeRate method to raise your threshold, or ` +
@@ -1113,39 +1339,36 @@ function checkFees(psbt, cache, opts) {
         );
     }
 }
-function checkInputsForPartialSig(inputs, action) {
-    inputs.forEach(input => {
-        const throws = (0, bip371_1.isTaprootInput)(input)
-            ? (0, bip371_1.checkTaprootInputForSigs)(input, action)
-            : (0, psbtutils_1.checkInputForSig)(input, action);
-        if (throws)
-            throw new Error('Can not modify transaction, signatures exist.');
+
+function checkInputsForPartialSig(inputs: PsbtInput[], action: string): void {
+    inputs.forEach((input) => {
+        const throws = isTaprootInput(input)
+            ? checkTaprootInputForSigs(input, action)
+            : checkInputForSig(input, action);
+        if (throws) throw new Error('Can not modify transaction, signatures exist.');
     });
 }
-function checkPartialSigSighashes(input) {
+
+function checkPartialSigSighashes(input: PsbtInput): void {
     if (!input.sighashType || !input.partialSig) return;
     const { partialSig, sighashType } = input;
-    partialSig.forEach(pSig => {
+    partialSig.forEach((pSig) => {
         const { hashType } = bscript.signature.decode(pSig.signature);
         if (sighashType !== hashType) {
-            throw new Error(
-                'Signature sighash does not match input sighash type',
-            );
+            throw new Error('Signature sighash does not match input sighash type');
         }
     });
 }
-function checkScriptForPubkey(pubkey, script, action) {
-    if (!(0, psbtutils_1.pubkeyInScript)(pubkey, script)) {
-        throw new Error(
-            `Can not ${action} for this input with the key ${pubkey.toString(
-                'hex',
-            )}`,
-        );
+
+function checkScriptForPubkey(pubkey: Buffer, script: Buffer, action: string): void {
+    if (!pubkeyInScript(pubkey, script)) {
+        throw new Error(`Can not ${action} for this input with the key ${pubkey.toString('hex')}`);
     }
 }
-function checkTxEmpty(tx) {
+
+function checkTxEmpty(tx: Transaction): void {
     const isEmpty = tx.ins.every(
-        input =>
+        (input) =>
             input.script &&
             input.script.length === 0 &&
             input.witness &&
@@ -1155,26 +1378,33 @@ function checkTxEmpty(tx) {
         throw new Error('Format Error: Transaction ScriptSigs are not empty');
     }
 }
-function checkTxForDupeIns(tx, cache) {
-    tx.ins.forEach(input => {
+
+function checkTxForDupeIns(tx: Transaction, cache: PsbtCache): void {
+    tx.ins.forEach((input) => {
         checkTxInputCache(cache, input);
     });
 }
-function checkTxInputCache(cache, input) {
-    const key =
-        (0, bufferutils_1.reverseBuffer)(Buffer.from(input.hash)).toString(
-            'hex',
-        ) +
-        ':' +
-        input.index;
+
+function checkTxInputCache(cache: PsbtCache, input: { hash: Buffer; index: number }): void {
+    const key = reverseBuffer(Buffer.from(input.hash)).toString('hex') + ':' + input.index;
     if (cache.__TX_IN_CACHE[key]) throw new Error('Duplicate input detected.');
     cache.__TX_IN_CACHE[key] = 1;
 }
-function scriptCheckerFactory(payment, paymentScriptName) {
-    return (inputIndex, scriptPubKey, redeemScript, ioType) => {
+
+function scriptCheckerFactory(
+    payment: (a: Payment, opts?: PaymentOpts) => Payment,
+    paymentScriptName: string,
+): (idx: number, scriptPubKey: Buffer, redeemScript: Buffer, ioType: 'input' | 'output') => void {
+    return (
+        inputIndex: number,
+        scriptPubKey: Buffer,
+        redeemScript: Buffer,
+        ioType: 'input' | 'output',
+    ): void => {
         const redeemScriptOutput = payment({
             redeem: { output: redeemScript },
-        }).output;
+        }).output as Buffer;
+
         if (!scriptPubKey.equals(redeemScriptOutput)) {
             throw new Error(
                 `${paymentScriptName} for ${ioType} #${inputIndex} doesn't match the scriptPubKey in the prevout`,
@@ -1182,17 +1412,23 @@ function scriptCheckerFactory(payment, paymentScriptName) {
         }
     };
 }
+
 const checkRedeemScript = scriptCheckerFactory(payments.p2sh, 'Redeem script');
-const checkWitnessScript = scriptCheckerFactory(
-    payments.p2wsh,
-    'Witness script',
-);
-function getTxCacheValue(key, name, inputs, c, disableOutputChecks = false) {
-    if (!inputs.every(isFinalized))
-        throw new Error(`PSBT must be finalized to calculate ${name}`);
+const checkWitnessScript = scriptCheckerFactory(payments.p2wsh, 'Witness script');
+
+type TxCacheNumberKey = '__FEE_RATE' | '__FEE';
+
+function getTxCacheValue(
+    key: TxCacheNumberKey,
+    name: string,
+    inputs: PsbtInput[],
+    c: PsbtCache,
+    disableOutputChecks: boolean = false,
+): number | undefined {
+    if (!inputs.every(isFinalized)) throw new Error(`PSBT must be finalized to calculate ${name}`);
     if (key === '__FEE_RATE' && c.__FEE_RATE) return c.__FEE_RATE;
     if (key === '__FEE' && c.__FEE) return c.__FEE;
-    let tx;
+    let tx: Transaction;
     let mustFinalize = true;
     if (c.__EXTRACTED_TX) {
         tx = c.__EXTRACTED_TX;
@@ -1201,46 +1437,76 @@ function getTxCacheValue(key, name, inputs, c, disableOutputChecks = false) {
         tx = c.__TX.clone();
     }
     inputFinalizeGetAmts(inputs, tx, c, mustFinalize, disableOutputChecks);
-    if (key === '__FEE_RATE') return c.__FEE_RATE;
-    else if (key === '__FEE') return c.__FEE;
+    if (key === '__FEE_RATE') return c.__FEE_RATE!;
+    else if (key === '__FEE') return c.__FEE!;
 }
-function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH) {
+
+/**
+ * This function must do two things:
+ * 1. Check if the `input` can be finalized. If it can not be finalized, throw.
+ *   ie. `Can not finalize input #${inputIndex}`
+ * 2. Create the finalScriptSig and finalScriptWitness Buffers.
+ */
+type FinalScriptsFunc = (
+    inputIndex: number, // Which input is it?
+    input: PsbtInput, // The PSBT input contents
+    script: Buffer, // The "meaningful" locking script Buffer (redeemScript for P2SH etc.)
+    isSegwit: boolean, // Is it segwit?
+    isP2SH: boolean, // Is it P2SH?
+    isP2WSH: boolean, // Is it P2WSH?
+) => {
+    finalScriptSig: Buffer | undefined;
+    finalScriptWitness: Buffer | undefined;
+};
+type FinalTaprootScriptsFunc = (
+    inputIndex: number, // Which input is it?
+    input: PsbtInput, // The PSBT input contents
+    tapLeafHashToFinalize?: Buffer, // Only finalize this specific leaf
+) => {
+    finalScriptWitness: Buffer | undefined;
+};
+
+export function getFinalScripts(
+    inputIndex: number,
+    input: PsbtInput,
+    script: Buffer,
+    isSegwit: boolean,
+    isP2SH: boolean,
+    isP2WSH: boolean,
+): {
+    finalScriptSig: Buffer | undefined;
+    finalScriptWitness: Buffer | undefined;
+} {
     const scriptType = classifyScript(script);
     if (!canFinalize(input, script, scriptType))
         throw new Error(`Can not finalize input #${inputIndex}`);
-    return prepareFinalScripts(
-        script,
-        scriptType,
-        input.partialSig,
-        isSegwit,
-        isP2SH,
-        isP2WSH,
-    );
+    return prepareFinalScripts(script, scriptType, input.partialSig!, isSegwit, isP2SH, isP2WSH);
 }
-exports.getFinalScripts = getFinalScripts;
-function prepareFinalScripts(
-    script,
-    scriptType,
-    partialSig,
-    isSegwit,
-    isP2SH,
-    isP2WSH,
-) {
-    let finalScriptSig;
-    let finalScriptWitness;
+
+export function prepareFinalScripts(
+    script: Buffer,
+    scriptType: string,
+    partialSig: PartialSig[],
+    isSegwit: boolean,
+    isP2SH: boolean,
+    isP2WSH: boolean,
+): {
+    finalScriptSig: Buffer | undefined;
+    finalScriptWitness: Buffer | undefined;
+} {
+    let finalScriptSig: Buffer | undefined;
+    let finalScriptWitness: Buffer | undefined;
+
     // Wow, the payments API is very handy
-    const payment = getPayment(script, scriptType, partialSig);
+    const payment: payments.Payment = getPayment(script, scriptType, partialSig);
     const p2wsh = !isP2WSH ? null : payments.p2wsh({ redeem: payment });
     const p2sh = !isP2SH ? null : payments.p2sh({ redeem: p2wsh || payment });
+
     if (isSegwit) {
         if (p2wsh) {
-            finalScriptWitness = (0, psbtutils_1.witnessStackToScriptWitness)(
-                p2wsh.witness,
-            );
+            finalScriptWitness = witnessStackToScriptWitness(p2wsh.witness!);
         } else {
-            finalScriptWitness = (0, psbtutils_1.witnessStackToScriptWitness)(
-                payment.witness,
-            );
+            finalScriptWitness = witnessStackToScriptWitness(payment.witness!);
         }
         if (p2sh) {
             finalScriptSig = p2sh.input;
@@ -1257,15 +1523,18 @@ function prepareFinalScripts(
         finalScriptWitness,
     };
 }
-exports.prepareFinalScripts = prepareFinalScripts;
+
 function getHashAndSighashType(
-    inputs,
-    inputIndex,
-    pubkey,
-    cache,
-    sighashTypes,
-) {
-    const input = (0, utils_1.checkForInput)(inputs, inputIndex);
+    inputs: PsbtInput[],
+    inputIndex: number,
+    pubkey: Buffer,
+    cache: PsbtCache,
+    sighashTypes: number[],
+): {
+    hash: Buffer;
+    sighashType: number;
+} {
+    const input = checkForInput(inputs, inputIndex);
     const { hash, sighashType, script } = getHashForSig(
         inputIndex,
         input,
@@ -1273,40 +1542,53 @@ function getHashAndSighashType(
         false,
         sighashTypes,
     );
+
     checkScriptForPubkey(pubkey, script, 'sign');
     return {
         hash,
         sighashType,
     };
 }
-function getHashForSig(inputIndex, input, cache, forValidate, sighashTypes) {
+
+function getHashForSig(
+    inputIndex: number,
+    input: PsbtInput,
+    cache: PsbtCache,
+    forValidate: boolean,
+    sighashTypes?: number[],
+): {
+    script: Buffer;
+    hash: Buffer;
+    sighashType: number;
+} {
     const unsignedTx = cache.__TX;
-    const sighashType =
-        input.sighashType || transaction_1.Transaction.SIGHASH_ALL;
+    const sighashType = input.sighashType || Transaction.SIGHASH_ALL;
     checkSighashTypeAllowed(sighashType, sighashTypes);
-    let hash;
-    let prevout;
+
+    let hash: Buffer;
+    let prevout: Output;
+
     if (input.nonWitnessUtxo) {
-        const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(
-            cache,
-            input,
-            inputIndex,
-        );
+        const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(cache, input, inputIndex);
+
         const prevoutHash = unsignedTx.ins[inputIndex].hash;
         const utxoHash = nonWitnessUtxoTx.getHash();
+
         // If a non-witness UTXO is provided, its hash must match the hash specified in the prevout
         if (!prevoutHash.equals(utxoHash)) {
             throw new Error(
                 `Non-witness UTXO hash for input #${inputIndex} doesn't match the hash specified in the prevout`,
             );
         }
+
         const prevoutIndex = unsignedTx.ins[inputIndex].index;
-        prevout = nonWitnessUtxoTx.outs[prevoutIndex];
+        prevout = nonWitnessUtxoTx.outs[prevoutIndex] as Output;
     } else if (input.witnessUtxo) {
         prevout = input.witnessUtxo;
     } else {
         throw new Error('Need a Utxo input item for signing');
     }
+
     const { meaningfulScript, type } = getMeaningfulScript(
         prevout.script,
         inputIndex,
@@ -1314,6 +1596,7 @@ function getHashForSig(inputIndex, input, cache, forValidate, sighashTypes) {
         input.redeemScript,
         input.witnessScript,
     );
+
     if (['p2sh-p2wsh', 'p2wsh'].indexOf(type) >= 0) {
         hash = unsignedTx.hashForWitnessV0(
             inputIndex,
@@ -1321,23 +1604,15 @@ function getHashForSig(inputIndex, input, cache, forValidate, sighashTypes) {
             prevout.value,
             sighashType,
         );
-    } else if ((0, psbtutils_1.isP2WPKH)(meaningfulScript)) {
+    } else if (isP2WPKH(meaningfulScript)) {
         // P2WPKH uses the P2PKH template for prevoutScript when signing
         const signingScript = payments.p2pkh({
             hash: meaningfulScript.slice(2),
-        }).output;
-        hash = unsignedTx.hashForWitnessV0(
-            inputIndex,
-            signingScript,
-            prevout.value,
-            sighashType,
-        );
+        }).output!;
+        hash = unsignedTx.hashForWitnessV0(inputIndex, signingScript, prevout.value, sighashType);
     } else {
         // non-segwit
-        if (
-            input.nonWitnessUtxo === undefined &&
-            cache.__UNSAFE_SIGN_NONSEGWIT === false
-        )
+        if (input.nonWitnessUtxo === undefined && cache.__UNSAFE_SIGN_NONSEGWIT === false)
             throw new Error(
                 `Input #${inputIndex} has witnessUtxo but non-segwit script: ` +
                     `${meaningfulScript.toString('hex')}`,
@@ -1352,19 +1627,22 @@ function getHashForSig(inputIndex, input, cache, forValidate, sighashTypes) {
                     'BIP174 compliant.\n*********************\nPROCEED WITH CAUTION!\n' +
                     '*********************',
             );
-        hash = unsignedTx.hashForSignature(
-            inputIndex,
-            meaningfulScript,
-            sighashType,
-        );
+        hash = unsignedTx.hashForSignature(inputIndex, meaningfulScript, sighashType);
     }
+
     return {
         script: meaningfulScript,
         sighashType,
         hash,
     };
 }
-function getAllTaprootHashesForSig(inputIndex, input, inputs, cache) {
+
+function getAllTaprootHashesForSig(
+    inputIndex: number,
+    input: PsbtInput,
+    inputs: PsbtInput[],
+    cache: PsbtCache,
+): { pubkey: Buffer; hash: Buffer; leafHash?: Buffer }[] {
     const allPublicKeys = [];
     if (input.tapInternalKey) {
         const key = getPrevoutTaprootKey(inputIndex, input, cache);
@@ -1372,45 +1650,56 @@ function getAllTaprootHashesForSig(inputIndex, input, inputs, cache) {
             allPublicKeys.push(key);
         }
     }
+
     if (input.tapScriptSig) {
-        const tapScriptPubkeys = input.tapScriptSig.map(tss => tss.pubkey);
+        const tapScriptPubkeys = input.tapScriptSig.map((tss) => tss.pubkey);
         allPublicKeys.push(...tapScriptPubkeys);
     }
-    const allHashes = allPublicKeys.map(pubicKey =>
+
+    const allHashes = allPublicKeys.map((pubicKey) =>
         getTaprootHashesForSig(inputIndex, input, inputs, pubicKey, cache),
     );
+
     return allHashes.flat();
 }
-function getPrevoutTaprootKey(inputIndex, input, cache) {
+
+function getPrevoutTaprootKey(
+    inputIndex: number,
+    input: PsbtInput,
+    cache: PsbtCache,
+): Buffer | null {
     const { script } = getScriptAndAmountFromUtxo(inputIndex, input, cache);
-    return (0, psbtutils_1.isP2TR)(script) ? script.subarray(2, 34) : null;
+    return isP2TR(script) ? script.subarray(2, 34) : null;
 }
-function trimTaprootSig(signature) {
+
+function trimTaprootSig(signature: Buffer): Buffer {
     return signature.length === 64 ? signature : signature.subarray(0, 64);
 }
+
 function getTaprootHashesForSig(
-    inputIndex,
-    input,
-    inputs,
-    pubkey,
-    cache,
-    tapLeafHashToSign,
-    allowedSighashTypes,
-) {
+    inputIndex: number,
+    input: PsbtInput,
+    inputs: PsbtInput[],
+    pubkey: Buffer,
+    cache: PsbtCache,
+    tapLeafHashToSign?: Buffer,
+    allowedSighashTypes?: number[],
+): { pubkey: Buffer; hash: Buffer; leafHash?: Buffer }[] {
     const unsignedTx = cache.__TX;
-    const sighashType =
-        input.sighashType || transaction_1.Transaction.SIGHASH_DEFAULT;
+
+    const sighashType = input.sighashType || Transaction.SIGHASH_DEFAULT;
     checkSighashTypeAllowed(sighashType, allowedSighashTypes);
-    const prevOuts = inputs.map((i, index) =>
+
+    const prevOuts: Output[] = inputs.map((i, index) =>
         getScriptAndAmountFromUtxo(index, i, cache),
     );
-    const signingScripts = prevOuts.map(o => o.script);
-    const values = prevOuts.map(o => o.value);
+    const signingScripts = prevOuts.map((o) => o.script);
+    const values = prevOuts.map((o) => o.value);
+
     const hashes = [];
     if (input.tapInternalKey && !tapLeafHashToSign) {
-        const outputKey =
-            getPrevoutTaprootKey(inputIndex, input, cache) || Buffer.from([]);
-        if ((0, bip371_1.toXOnly)(pubkey).equals(outputKey)) {
+        const outputKey = getPrevoutTaprootKey(inputIndex, input, cache) || Buffer.from([]);
+        if (toXOnly(pubkey).equals(outputKey)) {
             const tapKeyHash = unsignedTx.hashForWitnessV1(
                 inputIndex,
                 signingScripts,
@@ -1420,22 +1709,18 @@ function getTaprootHashesForSig(
             hashes.push({ pubkey, hash: tapKeyHash });
         }
     }
+
     const tapLeafHashes = (input.tapLeafScript || [])
-        .filter(tapLeaf =>
-            (0, psbtutils_1.pubkeyInScript)(pubkey, tapLeaf.script),
-        )
-        .map(tapLeaf => {
-            const hash = (0, bip341_1.tapleafHash)({
+        .filter((tapLeaf) => pubkeyInScript(pubkey, tapLeaf.script))
+        .map((tapLeaf) => {
+            const hash = tapleafHash({
                 output: tapLeaf.script,
                 version: tapLeaf.leafVersion,
             });
             return Object.assign({ hash }, tapLeaf);
         })
-        .filter(
-            tapLeaf =>
-                !tapLeafHashToSign || tapLeafHashToSign.equals(tapLeaf.hash),
-        )
-        .map(tapLeaf => {
+        .filter((tapLeaf) => !tapLeafHashToSign || tapLeafHashToSign.equals(tapLeaf.hash))
+        .map((tapLeaf) => {
             const tapScriptHash = unsignedTx.hashForWitnessV1(
                 inputIndex,
                 signingScripts,
@@ -1443,15 +1728,18 @@ function getTaprootHashesForSig(
                 sighashType,
                 tapLeaf.hash,
             );
+
             return {
                 pubkey,
                 hash: tapScriptHash,
                 leafHash: tapLeaf.hash,
             };
         });
+
     return hashes.concat(tapLeafHashes);
 }
-function checkSighashTypeAllowed(sighashType, sighashTypes) {
+
+function checkSighashTypeAllowed(sighashType: number, sighashTypes?: number[]): void {
     if (sighashTypes && sighashTypes.indexOf(sighashType) < 0) {
         const str = sighashTypeToString(sighashType);
         throw new Error(
@@ -1460,8 +1748,13 @@ function checkSighashTypeAllowed(sighashType, sighashTypes) {
         );
     }
 }
-function getPayment(script, scriptType, partialSig) {
-    let payment;
+
+function getPayment(
+    script: Buffer,
+    scriptType: string,
+    partialSig: PartialSig[],
+): payments.Payment {
+    let payment: payments.Payment;
     switch (scriptType) {
         case 'multisig':
             const sigs = getSortedSigs(script, partialSig);
@@ -1491,11 +1784,23 @@ function getPayment(script, scriptType, partialSig) {
             });
             break;
     }
-    return payment;
+    return payment!;
 }
-function getScriptFromInput(inputIndex, input, cache) {
+
+interface GetScriptReturn {
+    script: Buffer | null;
+    isSegwit: boolean;
+    isP2SH: boolean;
+    isP2WSH: boolean;
+}
+
+function getScriptFromInput(
+    inputIndex: number,
+    input: PsbtInput,
+    cache: PsbtCache,
+): GetScriptReturn {
     const unsignedTx = cache.__TX;
-    const res = {
+    const res: GetScriptReturn = {
         script: null,
         isSegwit: false,
         isP2SH: false,
@@ -1509,116 +1814,124 @@ function getScriptFromInput(inputIndex, input, cache) {
         res.script = input.redeemScript;
     } else {
         if (input.nonWitnessUtxo) {
-            const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(
-                cache,
-                input,
-                inputIndex,
-            );
+            const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(cache, input, inputIndex);
             const prevoutIndex = unsignedTx.ins[inputIndex].index;
             res.script = nonWitnessUtxoTx.outs[prevoutIndex].script;
         } else if (input.witnessUtxo) {
             res.script = input.witnessUtxo.script;
         }
     }
-    if (input.witnessScript || (0, psbtutils_1.isP2WPKH)(res.script)) {
+    if (input.witnessScript || isP2WPKH(res.script!)) {
         res.isSegwit = true;
     }
     return res;
 }
-function getSignersFromHD(inputIndex, inputs, hdKeyPair) {
-    const input = (0, utils_1.checkForInput)(inputs, inputIndex);
+
+function getSignersFromHD(
+    inputIndex: number,
+    inputs: PsbtInput[],
+    hdKeyPair: HDSigner | HDSignerAsync,
+): (HDSigner | HDSignerAsync)[] {
+    const input = checkForInput(inputs, inputIndex);
     if (!input.bip32Derivation || input.bip32Derivation.length === 0) {
         throw new Error('Need bip32Derivation to sign with HD');
     }
     const myDerivations = input.bip32Derivation
-        .map(bipDv => {
+        .map((bipDv) => {
             if (bipDv.masterFingerprint.equals(hdKeyPair.fingerprint)) {
                 return bipDv;
             } else {
                 return;
             }
         })
-        .filter(v => !!v);
+        .filter((v) => !!v);
     if (myDerivations.length === 0) {
         throw new Error(
             'Need one bip32Derivation masterFingerprint to match the HDSigner fingerprint',
         );
     }
-    return myDerivations.map(bipDv => {
-        const node = hdKeyPair.derivePath(bipDv.path);
-        if (!bipDv.pubkey.equals(node.publicKey)) {
+
+    return myDerivations.map((bipDv) => {
+        const node = hdKeyPair.derivePath(bipDv!.path);
+        if (!bipDv!.pubkey.equals(node.publicKey)) {
             throw new Error('pubkey did not match bip32Derivation');
         }
         return node;
     });
 }
-function getSortedSigs(script, partialSig) {
+
+function getSortedSigs(script: Buffer, partialSig: PartialSig[]): Buffer[] {
     const p2ms = payments.p2ms({ output: script });
     // for each pubkey in order of p2ms script
-    return p2ms.pubkeys
-        .map(pk => {
+    return p2ms
+        .pubkeys!.map((pk) => {
             // filter partialSig array by pubkey being equal
             return (
-                partialSig.filter(ps => {
+                partialSig.filter((ps) => {
                     return ps.pubkey.equals(pk);
                 })[0] || {}
             ).signature;
             // Any pubkey without a match will return undefined
             // this last filter removes all the undefined items in the array.
         })
-        .filter(v => !!v);
+        .filter((v) => !!v);
 }
-function scriptWitnessToWitnessStack(buffer) {
+
+function scriptWitnessToWitnessStack(buffer: Buffer): Buffer[] {
     let offset = 0;
-    function readSlice(n) {
+
+    function readSlice(n: number): Buffer {
         offset += n;
         return buffer.slice(offset - n, offset);
     }
-    function readVarInt() {
+
+    function readVarInt(): number {
         const vi = varuint.decode(buffer, offset);
-        offset += varuint.decode.bytes;
+        offset += (varuint.decode as any).bytes;
         return vi;
     }
-    function readVarSlice() {
+
+    function readVarSlice(): Buffer {
         return readSlice(readVarInt());
     }
-    function readVector() {
+
+    function readVector(): Buffer[] {
         const count = readVarInt();
-        const vector = [];
+        const vector: Buffer[] = [];
         for (let i = 0; i < count; i++) vector.push(readVarSlice());
         return vector;
     }
+
     return readVector();
 }
-function sighashTypeToString(sighashType) {
-    let text =
-        sighashType & transaction_1.Transaction.SIGHASH_ANYONECANPAY
-            ? 'SIGHASH_ANYONECANPAY | '
-            : '';
+
+function sighashTypeToString(sighashType: number): string {
+    let text = sighashType & Transaction.SIGHASH_ANYONECANPAY ? 'SIGHASH_ANYONECANPAY | ' : '';
     const sigMod = sighashType & 0x1f;
     switch (sigMod) {
-        case transaction_1.Transaction.SIGHASH_ALL:
+        case Transaction.SIGHASH_ALL:
             text += 'SIGHASH_ALL';
             break;
-        case transaction_1.Transaction.SIGHASH_SINGLE:
+        case Transaction.SIGHASH_SINGLE:
             text += 'SIGHASH_SINGLE';
             break;
-        case transaction_1.Transaction.SIGHASH_NONE:
+        case Transaction.SIGHASH_NONE:
             text += 'SIGHASH_NONE';
             break;
     }
     return text;
 }
-function addNonWitnessTxCache(cache, input, inputIndex) {
-    cache.__NON_WITNESS_UTXO_BUF_CACHE[inputIndex] = input.nonWitnessUtxo;
-    const tx = transaction_1.Transaction.fromBuffer(input.nonWitnessUtxo);
-    cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex] = tx;
+
+function addNonWitnessTxCache(cache: PsbtCache, input: PsbtInput, inputIndex: number): void {
+    cache.__NON_WITNESS_UTXO_BUF_CACHE[inputIndex] = input.nonWitnessUtxo!;
+    cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex] = Transaction.fromBuffer(input.nonWitnessUtxo!);
+
     const self = cache;
     const selfIndex = inputIndex;
     delete input.nonWitnessUtxo;
     Object.defineProperty(input, 'nonWitnessUtxo', {
         enumerable: true,
-        get() {
+        get(): Buffer {
             const buf = self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex];
             const txCache = self.__NON_WITNESS_UTXO_TX_CACHE[selfIndex];
             if (buf !== undefined) {
@@ -1629,37 +1942,35 @@ function addNonWitnessTxCache(cache, input, inputIndex) {
                 return newBuf;
             }
         },
-        set(data) {
+        set(data: Buffer): void {
             self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = data;
         },
     });
 }
+
 function inputFinalizeGetAmts(
-    inputs,
-    tx,
-    cache,
-    mustFinalize,
-    disableOutputChecks,
-) {
+    inputs: PsbtInput[],
+    tx: Transaction,
+    cache: PsbtCache,
+    mustFinalize: boolean,
+    disableOutputChecks?: boolean,
+): void {
     let inputAmount = 0;
     inputs.forEach((input, idx) => {
-        if (mustFinalize && input.finalScriptSig)
-            tx.ins[idx].script = input.finalScriptSig;
+        if (mustFinalize && input.finalScriptSig) tx.ins[idx].script = input.finalScriptSig;
         if (mustFinalize && input.finalScriptWitness) {
-            tx.ins[idx].witness = scriptWitnessToWitnessStack(
-                input.finalScriptWitness,
-            );
+            tx.ins[idx].witness = scriptWitnessToWitnessStack(input.finalScriptWitness);
         }
         if (input.witnessUtxo) {
             inputAmount += input.witnessUtxo.value;
         } else if (input.nonWitnessUtxo) {
             const nwTx = nonWitnessUtxoTxFromCache(cache, input, idx);
             const vout = tx.ins[idx].index;
-            const out = nwTx.outs[vout];
+            const out = nwTx.outs[vout] as Output;
             inputAmount += out.value;
         }
     });
-    const outputAmount = tx.outs.reduce((total, o) => total + o.value, 0);
+    const outputAmount = (tx.outs as Output[]).reduce((total, o) => total + o.value, 0);
     const fee = inputAmount - outputAmount;
     if (!disableOutputChecks) {
         if (fee < 0) {
@@ -1671,36 +1982,49 @@ function inputFinalizeGetAmts(
     cache.__EXTRACTED_TX = tx;
     cache.__FEE_RATE = Math.floor(fee / bytes);
 }
-function nonWitnessUtxoTxFromCache(cache, input, inputIndex) {
+
+function nonWitnessUtxoTxFromCache(
+    cache: PsbtCache,
+    input: PsbtInput,
+    inputIndex: number,
+): Transaction {
     const c = cache.__NON_WITNESS_UTXO_TX_CACHE;
     if (!c[inputIndex]) {
         addNonWitnessTxCache(cache, input, inputIndex);
     }
     return c[inputIndex];
 }
-function getScriptFromUtxo(inputIndex, input, cache) {
+
+function getScriptFromUtxo(inputIndex: number, input: PsbtInput, cache: PsbtCache): Buffer {
     const { script } = getScriptAndAmountFromUtxo(inputIndex, input, cache);
     return script;
 }
-function getScriptAndAmountFromUtxo(inputIndex, input, cache) {
+
+function getScriptAndAmountFromUtxo(
+    inputIndex: number,
+    input: PsbtInput,
+    cache: PsbtCache,
+): { script: Buffer; value: number } {
     if (input.witnessUtxo !== undefined) {
         return {
             script: input.witnessUtxo.script,
             value: input.witnessUtxo.value,
         };
     } else if (input.nonWitnessUtxo !== undefined) {
-        const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(
-            cache,
-            input,
-            inputIndex,
-        );
+        const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(cache, input, inputIndex);
         const o = nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index];
         return { script: o.script, value: o.value };
     } else {
         throw new Error("Can't find pubkey in input without Utxo data");
     }
 }
-function pubkeyInInput(pubkey, input, inputIndex, cache) {
+
+function pubkeyInInput(
+    pubkey: Buffer,
+    input: PsbtInput,
+    inputIndex: number,
+    cache: PsbtCache,
+): boolean {
     const script = getScriptFromUtxo(inputIndex, input, cache);
     const { meaningfulScript } = getMeaningfulScript(
         script,
@@ -1709,9 +2033,15 @@ function pubkeyInInput(pubkey, input, inputIndex, cache) {
         input.redeemScript,
         input.witnessScript,
     );
-    return (0, psbtutils_1.pubkeyInScript)(pubkey, meaningfulScript);
+    return pubkeyInScript(pubkey, meaningfulScript);
 }
-function pubkeyInOutput(pubkey, output, outputIndex, cache) {
+
+function pubkeyInOutput(
+    pubkey: Buffer,
+    output: PsbtOutput,
+    outputIndex: number,
+    cache: PsbtCache,
+): boolean {
     const script = cache.__TX.outs[outputIndex].script;
     const { meaningfulScript } = getMeaningfulScript(
         script,
@@ -1720,24 +2050,21 @@ function pubkeyInOutput(pubkey, output, outputIndex, cache) {
         output.redeemScript,
         output.witnessScript,
     );
-    return (0, psbtutils_1.pubkeyInScript)(pubkey, meaningfulScript);
+    return pubkeyInScript(pubkey, meaningfulScript);
 }
-function redeemFromFinalScriptSig(finalScript) {
+
+function redeemFromFinalScriptSig(finalScript: Buffer | undefined): Buffer | undefined {
     if (!finalScript) return;
     const decomp = bscript.decompile(finalScript);
     if (!decomp) return;
     const lastItem = decomp[decomp.length - 1];
-    if (
-        !Buffer.isBuffer(lastItem) ||
-        isPubkeyLike(lastItem) ||
-        isSigLike(lastItem)
-    )
-        return;
+    if (!Buffer.isBuffer(lastItem) || isPubkeyLike(lastItem) || isSigLike(lastItem)) return;
     const sDecomp = bscript.decompile(lastItem);
     if (!sDecomp) return;
     return lastItem;
 }
-function redeemFromFinalWitnessScript(finalScript) {
+
+function redeemFromFinalWitnessScript(finalScript: Buffer | undefined): Buffer | undefined {
     if (!finalScript) return;
     const decomp = scriptWitnessToWitnessStack(finalScript);
     const lastItem = decomp[decomp.length - 1];
@@ -1746,7 +2073,8 @@ function redeemFromFinalWitnessScript(finalScript) {
     if (!sDecomp) return;
     return lastItem;
 }
-function compressPubkey(pubkey) {
+
+function compressPubkey(pubkey: Buffer): Buffer {
     if (pubkey.length === 65) {
         const parity = pubkey[64] & 1;
         const newKey = pubkey.slice(0, 33);
@@ -1755,71 +2083,92 @@ function compressPubkey(pubkey) {
     }
     return pubkey.slice();
 }
-function isPubkeyLike(buf) {
+
+function isPubkeyLike(buf: Buffer): boolean {
     return buf.length === 33 && bscript.isCanonicalPubKey(buf);
 }
-function isSigLike(buf) {
+
+function isSigLike(buf: Buffer): boolean {
     return bscript.isCanonicalScriptSignature(buf);
 }
+
 function getMeaningfulScript(
-    script,
-    index,
-    ioType,
-    redeemScript,
-    witnessScript,
-) {
-    const isP2SH = (0, psbtutils_1.isP2SHScript)(script);
-    const isP2SHP2WSH =
-        isP2SH && redeemScript && (0, psbtutils_1.isP2WSHScript)(redeemScript);
-    const isP2WSH = (0, psbtutils_1.isP2WSHScript)(script);
+    script: Buffer,
+    index: number,
+    ioType: 'input' | 'output',
+    redeemScript?: Buffer,
+    witnessScript?: Buffer,
+): {
+    meaningfulScript: Buffer;
+    type: 'p2sh' | 'p2wsh' | 'p2sh-p2wsh' | 'raw';
+} {
+    const isP2SH = isP2SHScript(script);
+    const isP2SHP2WSH = isP2SH && redeemScript && isP2WSHScript(redeemScript);
+    const isP2WSH = isP2WSHScript(script);
+
     if (isP2SH && redeemScript === undefined)
         throw new Error('scriptPubkey is P2SH but redeemScript missing');
     if ((isP2WSH || isP2SHP2WSH) && witnessScript === undefined)
-        throw new Error(
-            'scriptPubkey or redeemScript is P2WSH but witnessScript missing',
-        );
-    let meaningfulScript;
+        throw new Error('scriptPubkey or redeemScript is P2WSH but witnessScript missing');
+
+    let meaningfulScript: Buffer;
+
     if (isP2SHP2WSH) {
-        meaningfulScript = witnessScript;
-        checkRedeemScript(index, script, redeemScript, ioType);
-        checkWitnessScript(index, redeemScript, witnessScript, ioType);
+        meaningfulScript = witnessScript!;
+        checkRedeemScript(index, script, redeemScript!, ioType);
+        checkWitnessScript(index, redeemScript!, witnessScript!, ioType);
         checkInvalidP2WSH(meaningfulScript);
     } else if (isP2WSH) {
-        meaningfulScript = witnessScript;
-        checkWitnessScript(index, script, witnessScript, ioType);
+        meaningfulScript = witnessScript!;
+        checkWitnessScript(index, script, witnessScript!, ioType);
         checkInvalidP2WSH(meaningfulScript);
     } else if (isP2SH) {
-        meaningfulScript = redeemScript;
-        checkRedeemScript(index, script, redeemScript, ioType);
+        meaningfulScript = redeemScript!;
+        checkRedeemScript(index, script, redeemScript!, ioType);
     } else {
         meaningfulScript = script;
     }
     return {
         meaningfulScript,
-        type: isP2SHP2WSH
-            ? 'p2sh-p2wsh'
-            : isP2SH
-            ? 'p2sh'
-            : isP2WSH
-            ? 'p2wsh'
-            : 'raw',
+        type: isP2SHP2WSH ? 'p2sh-p2wsh' : isP2SH ? 'p2sh' : isP2WSH ? 'p2wsh' : 'raw',
     };
 }
-function checkInvalidP2WSH(script) {
-    if (
-        (0, psbtutils_1.isP2WPKH)(script) ||
-        (0, psbtutils_1.isP2SHScript)(script)
-    ) {
+
+function checkInvalidP2WSH(script: Buffer): void {
+    if (isP2WPKH(script) || isP2SHScript(script)) {
         throw new Error('P2WPKH or P2SH can not be contained within P2WSH');
     }
 }
-function classifyScript(script) {
-    if ((0, psbtutils_1.isP2WPKH)(script)) return 'witnesspubkeyhash';
-    if ((0, psbtutils_1.isP2PKH)(script)) return 'pubkeyhash';
-    if ((0, psbtutils_1.isP2MS)(script)) return 'multisig';
-    if ((0, psbtutils_1.isP2PK)(script)) return 'pubkey';
+
+type AllScriptType =
+    | 'witnesspubkeyhash'
+    | 'pubkeyhash'
+    | 'multisig'
+    | 'pubkey'
+    | 'nonstandard'
+    | 'p2sh-witnesspubkeyhash'
+    | 'p2sh-pubkeyhash'
+    | 'p2sh-multisig'
+    | 'p2sh-pubkey'
+    | 'p2sh-nonstandard'
+    | 'p2wsh-pubkeyhash'
+    | 'p2wsh-multisig'
+    | 'p2wsh-pubkey'
+    | 'p2wsh-nonstandard'
+    | 'p2sh-p2wsh-pubkeyhash'
+    | 'p2sh-p2wsh-multisig'
+    | 'p2sh-p2wsh-pubkey'
+    | 'p2sh-p2wsh-nonstandard';
+type ScriptType = 'witnesspubkeyhash' | 'pubkeyhash' | 'multisig' | 'pubkey' | 'nonstandard';
+
+function classifyScript(script: Buffer): ScriptType {
+    if (isP2WPKH(script)) return 'witnesspubkeyhash';
+    if (isP2PKH(script)) return 'pubkeyhash';
+    if (isP2MS(script)) return 'multisig';
+    if (isP2PK(script)) return 'pubkey';
     return 'nonstandard';
 }
-function range(n) {
+
+function range(n: number): number[] {
     return [...Array(n).keys()];
 }