@btc-vision/transaction 1.1.16 → 1.1.17

package/browser/keypair/Address.d.ts

@@ -9,11 +9,13 @@ export declare class Address extends Uint8Array {
     static wrap(bytes: ArrayLike<number>): Address;
     toHex(): string;
     toBuffer(): Buffer;
+    originalPublicKeyBuffer(): Buffer;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;
     set(publicKey: ArrayLike<number>): void;
     isValid(network: Network): boolean;
+    p2pk(): string;
     p2wpkh(network: Network): string;
     p2pkh(network: Network): string;
     p2shp2wpkh(network: Network): string;

package/browser/signer/SignerUtils.d.ts

@@ -0,0 +1,6 @@
+import { PsbtInput } from '@btc-vision/bitcoin';
+export declare function isTaprootInput(input: PsbtInput): boolean;
+export declare function getInputRelevantScript(input: PsbtInput): Buffer | null;
+export declare function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean;
+export declare function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number;
+export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;

package/browser/transaction/shared/TweakedTransaction.d.ts

@@ -48,7 +48,7 @@ export declare abstract class TweakedTransaction extends Logger {
     protected generateTapData(): Payment;
     protected generateScriptAddress(): Payment;
     protected getSignerKey(): Signer | ECPairInterface;
-    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean): Promise<void>;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean, errored?: boolean): Promise<void>;
     protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
@@ -60,6 +60,10 @@ export declare abstract class TweakedTransaction extends Logger {
         redeemScript: Buffer;
         outputScript: Buffer;
     } | undefined;
+    protected generateP2SHP2PKHRedeemScript(inputAddr: string): {
+        redeemScript: Buffer;
+        outputScript: Buffer;
+    } | undefined;
     protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended;
     protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
         finalScriptSig: Buffer | undefined;
@@ -68,11 +72,6 @@ export declare abstract class TweakedTransaction extends Logger {
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     private attemptSignTaproot;
     private isTaprootScriptSpend;
-    private isTaprootInput;
-    private canSignNonTaprootInput;
-    private getInputRelevantScript;
-    private pubkeyInScript;
-    private pubkeyPositionInScript;
     private signTaprootInput;
     private signNonTaprootInput;
 }

package/browser/utxo/interfaces/IUTXO.d.ts

@@ -27,4 +27,5 @@ export interface RawUTXOResponse {
     readonly outputIndex: number;
     readonly value: string;
     readonly scriptPubKey: ScriptPubKey;
+    readonly raw: string;
 }

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.1.16";
+export declare const version = "1.1.17";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.1.16';
+export const version = '1.1.17';

package/build/keypair/Address.d.ts

@@ -9,11 +9,13 @@ export declare class Address extends Uint8Array {
     static wrap(bytes: ArrayLike<number>): Address;
     toHex(): string;
     toBuffer(): Buffer;
+    originalPublicKeyBuffer(): Buffer;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;
     set(publicKey: ArrayLike<number>): void;
     isValid(network: Network): boolean;
+    p2pk(): string;
     p2wpkh(network: Network): string;
     p2pkh(network: Network): string;
     p2shp2wpkh(network: Network): string;

package/build/keypair/Address.js

@@ -63,6 +63,12 @@ export class Address extends Uint8Array {
     toBuffer() {
         return Buffer.from(this);
     }
+    originalPublicKeyBuffer() {
+        if (!__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
+            throw new Error('Public key not set');
+        }
+        return Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"));
+    }
     equals(a) {
         const b = this;
         if (a.length !== b.length) {
@@ -123,6 +129,9 @@ export class Address extends Uint8Array {
     isValid(network) {
         return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
     }
+    p2pk() {
+        return this.toHex();
+    }
     p2wpkh(network) {
         return EcKeyPair.getP2WPKHAddress(this.keyPair, network);
     }

package/build/signer/SignerUtils.d.ts

@@ -0,0 +1,6 @@
+import { PsbtInput } from '@btc-vision/bitcoin';
+export declare function isTaprootInput(input: PsbtInput): boolean;
+export declare function getInputRelevantScript(input: PsbtInput): Buffer | null;
+export declare function canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean;
+export declare function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number;
+export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;

package/build/signer/SignerUtils.js

@@ -0,0 +1,56 @@
+import { crypto as bitCrypto } from '@btc-vision/bitcoin';
+import { isP2TR } from '@btc-vision/bitcoin/src/psbt/psbtutils.js';
+import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import * as bscript from '@btc-vision/bitcoin/src/script.js';
+export function isTaprootInput(input) {
+    return (input &&
+        !!(input.tapInternalKey ||
+            input.tapMerkleRoot ||
+            (input.tapLeafScript && input.tapLeafScript.length) ||
+            (input.tapBip32Derivation && input.tapBip32Derivation.length) ||
+            (input.witnessUtxo && isP2TR(input.witnessUtxo.script))));
+}
+export function getInputRelevantScript(input) {
+    if (input.redeemScript) {
+        return input.redeemScript;
+    }
+    if (input.witnessScript) {
+        return input.witnessScript;
+    }
+    if (input.witnessUtxo) {
+        return input.witnessUtxo.script;
+    }
+    if (input.nonWitnessUtxo) {
+    }
+    return null;
+}
+export function canSignNonTaprootInput(input, publicKey) {
+    if ((input.nonWitnessUtxo &&
+        !input.redeemScript &&
+        !input.witnessScript &&
+        !input.witnessUtxo) ||
+        input.redeemScript) {
+        return true;
+    }
+    const script = getInputRelevantScript(input);
+    if (script) {
+        return pubkeyInScript(publicKey, script);
+    }
+    return false;
+}
+export function pubkeyPositionInScript(pubkey, script) {
+    const pubkeyHash = bitCrypto.hash160(pubkey);
+    const pubkeyXOnly = toXOnly(pubkey);
+    const decompiled = bscript.decompile(script);
+    if (decompiled === null)
+        throw new Error('Unknown script error');
+    const a = decompiled.findIndex((element) => {
+        if (typeof element === 'number')
+            return false;
+        return element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly);
+    });
+    return a;
+}
+export function pubkeyInScript(pubkey, script) {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}

package/build/transaction/browser/extensions/UnisatSigner.js

@@ -1,8 +1,9 @@
-import { crypto as bitCrypto, networks, opcodes, Psbt, script as bitScript, } from '@btc-vision/bitcoin';
+import { crypto as bitCrypto, networks, Psbt, script as bitScript, } from '@btc-vision/bitcoin';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { UnisatNetwork } from '../types/Unisat.js';
 import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUtils.js';
 export class UnisatSigner extends CustomKeypair {
     constructor() {
         super();
@@ -147,12 +148,9 @@ export class UnisatSigner extends CustomKeypair {
                         }
                     }
                 }
-                else {
-                    const script = getInputRelevantScript(input);
-                    if (script && pubkeyInScript(this.publicKey, script)) {
-                        needsToSign = true;
-                        viaTaproot = false;
-                    }
+                else if (canSignNonTaprootInput(input, this.publicKey)) {
+                    needsToSign = true;
+                    viaTaproot = false;
                 }
                 if (needsToSign) {
                     return {
@@ -248,31 +246,6 @@ export class UnisatSigner extends CustomKeypair {
         return nonDuplicate;
     }
 }
-function isTaprootInput(input) {
-    if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
-        return true;
-    }
-    if (input.witnessUtxo) {
-        const script = input.witnessUtxo.script;
-        return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
-    }
-    return false;
-}
-function getInputRelevantScript(input) {
-    if (input.redeemScript) {
-        return input.redeemScript;
-    }
-    if (input.witnessScript) {
-        return input.witnessScript;
-    }
-    if (input.witnessUtxo) {
-        return input.witnessUtxo.script;
-    }
-    if (input.nonWitnessUtxo) {
-        return null;
-    }
-    return null;
-}
 function pubkeyInScript(pubkey, script) {
     return pubkeyPositionInScript(pubkey, script) !== -1;
 }

package/build/transaction/browser/extensions/XverseSigner.js

@@ -1,7 +1,8 @@
-import { crypto as bitCrypto, script as bitScript, networks, opcodes, Psbt, } from '@btc-vision/bitcoin';
+import { networks, Psbt } from '@btc-vision/bitcoin';
 import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
+import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../../signer/SignerUtils.js';
 export class XverseSigner extends CustomKeypair {
     constructor() {
         super();
@@ -145,12 +146,9 @@ export class XverseSigner extends CustomKeypair {
                         }
                     }
                 }
-                else {
-                    const script = getInputRelevantScript(input);
-                    if (script && pubkeyInScript(this.publicKey, script)) {
-                        needsToSign = true;
-                        viaTaproot = false;
-                    }
+                else if (canSignNonTaprootInput(input, this.publicKey)) {
+                    needsToSign = true;
+                    viaTaproot = false;
                 }
                 if (needsToSign) {
                     return {
@@ -256,44 +254,3 @@ export class XverseSigner extends CustomKeypair {
         return nonDuplicate;
     }
 }
-function isTaprootInput(input) {
-    if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
-        return true;
-    }
-    if (input.witnessUtxo) {
-        const script = input.witnessUtxo.script;
-        return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
-    }
-    return false;
-}
-function getInputRelevantScript(input) {
-    if (input.redeemScript) {
-        return input.redeemScript;
-    }
-    if (input.witnessScript) {
-        return input.witnessScript;
-    }
-    if (input.witnessUtxo) {
-        return input.witnessUtxo.script;
-    }
-    if (input.nonWitnessUtxo) {
-        return null;
-    }
-    return null;
-}
-function pubkeyInScript(pubkey, script) {
-    return pubkeyPositionInScript(pubkey, script) !== -1;
-}
-function pubkeyPositionInScript(pubkey, script) {
-    const pubkeyHash = bitCrypto.hash160(pubkey);
-    const pubkeyXOnly = toXOnly(pubkey);
-    const decompiled = bitScript.decompile(script);
-    if (decompiled === null)
-        throw new Error('Unknown script error');
-    return decompiled.findIndex((element) => {
-        if (typeof element === 'number')
-            return false;
-        return (Buffer.isBuffer(element) &&
-            (element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly)));
-    });
-}

package/build/transaction/builders/FundingTransaction.js

@@ -1,4 +1,5 @@
 import { TransactionType } from '../enums/TransactionType.js';
+import { opcodes, script } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 export class FundingTransaction extends TransactionBuilder {
     constructor(parameters) {
@@ -17,9 +18,13 @@ export class FundingTransaction extends TransactionBuilder {
             this.splitInputs(this.amount);
         }
         else if (this.isPubKeyDestination) {
+            const p2pkScript = script.compile([
+                Buffer.from(this.to.replace('0x', ''), 'hex'),
+                opcodes.OP_CHECKSIG,
+            ]);
             this.addOutput({
                 value: Number(this.amount),
-                script: Buffer.from(this.to.slice(2), 'hex'),
+                script: p2pkScript,
             });
         }
         else {

package/build/transaction/builders/TransactionBuilder.js

@@ -25,7 +25,9 @@ export class TransactionBuilder extends TweakedTransaction {
         this.priorityFee = parameters.priorityFee ?? 0n;
         this.utxos = parameters.utxos;
         this.to = parameters.to || undefined;
-        this.isPubKeyDestination = this.to ? this.to.startsWith('0x') : false;
+        this.isPubKeyDestination = this.to
+            ? AddressVerificator.isValidPublicKey(this.to, this.network)
+            : false;
         this.optionalOutputs = parameters.optionalOutputs;
         this.from = TransactionBuilder.getFrom(parameters.from, this.signer, this.network);
         this.totalInputAmount = this.calculateTotalUTXOAmount();

package/build/transaction/shared/TweakedTransaction.d.ts

@@ -48,7 +48,7 @@ export declare abstract class TweakedTransaction extends Logger {
     protected generateTapData(): Payment;
     protected generateScriptAddress(): Payment;
     protected getSignerKey(): Signer | ECPairInterface;
-    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean): Promise<void>;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean, errored?: boolean): Promise<void>;
     protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
@@ -60,6 +60,10 @@ export declare abstract class TweakedTransaction extends Logger {
         redeemScript: Buffer;
         outputScript: Buffer;
     } | undefined;
+    protected generateP2SHP2PKHRedeemScript(inputAddr: string): {
+        redeemScript: Buffer;
+        outputScript: Buffer;
+    } | undefined;
     protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended;
     protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
         finalScriptSig: Buffer | undefined;
@@ -68,11 +72,6 @@ export declare abstract class TweakedTransaction extends Logger {
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     private attemptSignTaproot;
     private isTaprootScriptSpend;
-    private isTaprootInput;
-    private canSignNonTaprootInput;
-    private getInputRelevantScript;
-    private pubkeyInScript;
-    private pubkeyPositionInScript;
     private signTaprootInput;
     private signNonTaprootInput;
 }

package/build/transaction/shared/TweakedTransaction.js

@@ -2,9 +2,9 @@ import { Logger } from '@btc-vision/logger';
 import { address as bitAddress, crypto as bitCrypto, getFinalScripts, opcodes, payments, script, } from '@btc-vision/bitcoin';
 import { TweakedSigner } from '../../signer/TweakedSigner.js';
 import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
-import { AddressTypes, AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { varuint } from '@btc-vision/bitcoin/src/bufferutils.js';
-import * as bscript from '@btc-vision/bitcoin/src/script.js';
+import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../signer/SignerUtils.js';
+import { isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, } from '@btc-vision/bitcoin/src/psbt/psbtutils.js';
 export var TransactionSequence;
 (function (TransactionSequence) {
     TransactionSequence[TransactionSequence["REPLACE_BY_FEE"] = 4294967293] = "REPLACE_BY_FEE";
@@ -154,36 +154,42 @@ export class TweakedTransaction extends Logger {
     getSignerKey() {
         return this.signer;
     }
-    async signInput(transaction, input, i, signer, reverse = false) {
+    async signInput(transaction, input, i, signer, reverse = false, errored = false) {
         const publicKey = signer.publicKey;
-        let isTaproot = this.isTaprootInput(input);
+        let isTaproot = isTaprootInput(input);
         if (reverse) {
             isTaproot = !isTaproot;
         }
         let signed = false;
+        let didError = false;
         if (isTaproot) {
             try {
                 await this.attemptSignTaproot(transaction, input, i, signer, publicKey);
                 signed = true;
             }
             catch (e) {
-                this.error(`Failed to sign Taproot script path input ${i}: ${e}`);
+                this.error(`Failed to sign Taproot script path input ${i} (reverse: ${reverse}): ${e.message}`);
+                didError = true;
             }
         }
         else {
-            if (!reverse ? this.canSignNonTaprootInput(input, publicKey) : true) {
+            if (!reverse ? canSignNonTaprootInput(input, publicKey) : true) {
                 try {
                     await this.signNonTaprootInput(signer, transaction, i);
                     signed = true;
                 }
                 catch (e) {
-                    this.error(`Failed to sign non-Taproot input ${i}: ${e}`);
+                    this.error(`Failed to sign non-Taproot input ${i}: ${e.stack}`);
+                    didError = true;
                 }
             }
         }
         if (!signed) {
+            if (didError && errored) {
+                throw new Error(`Failed to sign input ${i} with the provided signer.`);
+            }
             try {
-                await this.signInput(transaction, input, i, signer, true);
+                await this.signInput(transaction, input, i, signer, true, didError);
             }
             catch {
                 throw new Error(`Cannot sign input ${i} with the provided signer.`);
@@ -296,51 +302,127 @@ export class TweakedTransaction extends Logger {
         }
         return;
     }
+    generateP2SHP2PKHRedeemScript(inputAddr) {
+        const pubkey = Buffer.isBuffer(this.signer.publicKey)
+            ? this.signer.publicKey
+            : Buffer.from(this.signer.publicKey, 'hex');
+        const w = payments.p2wpkh({
+            pubkey: pubkey,
+            network: this.network,
+        });
+        const p = payments.p2sh({
+            redeem: w,
+            network: this.network,
+        });
+        const address = p.address;
+        const redeemScript = p.redeem?.output;
+        if (!redeemScript) {
+            throw new Error('Failed to generate P2SH-P2WPKH redeem script');
+        }
+        if (address === inputAddr && p.redeem && p.redeem.output && p.output) {
+            return {
+                redeemScript: p.redeem.output,
+                outputScript: p.output,
+            };
+        }
+        return;
+    }
     generatePsbtInputExtended(utxo, i) {
+        const script = Buffer.from(utxo.scriptPubKey.hex, 'hex');
         const input = {
             hash: utxo.transactionId,
             index: utxo.outputIndex,
             sequence: this.sequence,
             witnessUtxo: {
                 value: Number(utxo.value),
-                script: Buffer.from(utxo.scriptPubKey.hex, 'hex'),
+                script,
             },
         };
-        if (utxo.scriptPubKey.address) {
-            try {
-                const addressType = AddressVerificator.detectAddressType(utxo.scriptPubKey.address, this.network);
-                if (addressType === AddressTypes.P2SH_OR_P2SH_P2WPKH) {
-                    const redeemScript = this.generateP2SHRedeemScriptLegacy(utxo.scriptPubKey.address);
-                    if (!redeemScript) {
-                        throw new Error('Failed to generate redeem script');
-                    }
-                    input.redeemScript = redeemScript.outputScript;
-                    input.witnessScript = redeemScript.redeemScript;
+        if (isP2PKH(script)) {
+            if (utxo.nonWitnessUtxo) {
+                input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
+                    ? utxo.nonWitnessUtxo
+                    : Buffer.from(utxo.nonWitnessUtxo, 'hex');
+            }
+            else {
+                throw new Error('Missing nonWitnessUtxo for P2PKH UTXO');
+            }
+        }
+        else if (isP2WPKH(script)) {
+        }
+        else if (isP2WSHScript(script)) {
+            if (!utxo.witnessScript) {
+                throw new Error('Missing witnessScript for P2WSH UTXO');
+            }
+            input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
+                ? utxo.witnessScript
+                : Buffer.from(utxo.witnessScript, 'hex');
+        }
+        else if (isP2SHScript(script)) {
+            let redeemScriptBuf;
+            if (utxo.redeemScript) {
+                redeemScriptBuf = Buffer.isBuffer(utxo.redeemScript)
+                    ? utxo.redeemScript
+                    : Buffer.from(utxo.redeemScript, 'hex');
+            }
+            else {
+                if (!utxo.scriptPubKey.address) {
+                    throw new Error('Missing redeemScript and no address to regenerate it for P2SH UTXO');
+                }
+                const legacyScripts = this.generateP2SHP2PKHRedeemScript(utxo.scriptPubKey.address);
+                if (!legacyScripts) {
+                    throw new Error('Missing redeemScript for P2SH UTXO and unable to regenerate');
                 }
+                redeemScriptBuf = legacyScripts.redeemScript;
             }
-            catch (e) {
-                this.error(`Failed to detect address type for ${utxo.scriptPubKey.address} - ${e}`);
+            input.redeemScript = redeemScriptBuf;
+            const payment = payments.p2sh({ redeem: { output: input.redeemScript } });
+            if (!payment.redeem) {
+                throw new Error('Failed to extract redeem script from P2SH UTXO');
+            }
+            const redeemOutput = payment.redeem.output;
+            if (!redeemOutput) {
+                throw new Error('Failed to extract redeem output from P2SH UTXO');
+            }
+            if (utxo.nonWitnessUtxo) {
+                input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
+                    ? utxo.nonWitnessUtxo
+                    : Buffer.from(utxo.nonWitnessUtxo, 'hex');
+            }
+            if (isP2WPKH(redeemOutput)) {
+                delete input.nonWitnessUtxo;
+            }
+            else if (isP2WSHScript(redeemOutput)) {
+                delete input.nonWitnessUtxo;
+                if (!input.witnessScript) {
+                    throw new Error('Missing witnessScript for P2SH-P2WSH UTXO');
+                }
+            }
+            else {
+                delete input.witnessUtxo;
             }
         }
-        if (utxo.nonWitnessUtxo) {
-            input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
-                ? utxo.nonWitnessUtxo
-                : Buffer.from(utxo.nonWitnessUtxo, 'hex');
-        }
-        if (utxo.redeemScript) {
-            input.redeemScript = Buffer.isBuffer(utxo.redeemScript)
-                ? utxo.redeemScript
-                : Buffer.from(utxo.redeemScript, 'hex');
-            if (utxo.witnessScript) {
-                input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
-                    ? utxo.witnessScript
-                    : Buffer.from(utxo.witnessScript, 'hex');
+        else if (isP2TR(script)) {
+            if (this.sighashTypes) {
+                const inputSign = TweakedTransaction.calculateSignHash(this.sighashTypes);
+                if (inputSign)
+                    input.sighashType = inputSign;
+            }
+            this.tweakSigner();
+            input.tapInternalKey = this.internalPubKeyToXOnly();
+        }
+        else if (isP2PK(script) || isP2MS(script)) {
+            if (utxo.nonWitnessUtxo) {
+                input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
+                    ? utxo.nonWitnessUtxo
+                    : Buffer.from(utxo.nonWitnessUtxo, 'hex');
+            }
+            else {
+                throw new Error('Missing nonWitnessUtxo for P2PK or P2MS UTXO');
             }
         }
-        if (this.sighashTypes) {
-            const inputSign = TweakedTransaction.calculateSignHash(this.sighashTypes);
-            if (inputSign)
-                input.sighashType = inputSign;
+        else {
+            this.error(`Unknown or unsupported script type for output: ${utxo.scriptPubKey.hex}`);
         }
         if (this.tapLeafScript) {
             input.tapLeafScript = [this.tapLeafScript];
@@ -348,11 +430,6 @@ export class TweakedTransaction extends Logger {
         if (i === 0 && this.nonWitnessUtxo) {
             input.nonWitnessUtxo = this.nonWitnessUtxo;
         }
-        if (utxo.scriptPubKey.address &&
-            AddressVerificator.isValidP2TRAddress(utxo.scriptPubKey.address, this.network)) {
-            this.tweakSigner();
-            input.tapInternalKey = this.internalPubKeyToXOnly();
-        }
         return input;
     }
     async signInputsWalletBased(transaction) {
@@ -389,60 +466,13 @@ export class TweakedTransaction extends Logger {
     isTaprootScriptSpend(input, publicKey) {
         if (input.tapLeafScript && input.tapLeafScript.length > 0) {
             for (const tapLeafScript of input.tapLeafScript) {
-                if (this.pubkeyInScript(publicKey, tapLeafScript.script)) {
+                if (pubkeyInScript(publicKey, tapLeafScript.script)) {
                     return true;
                 }
             }
         }
         return false;
     }
-    isTaprootInput(input) {
-        if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
-            return true;
-        }
-        if (input.witnessUtxo) {
-            const script = input.witnessUtxo.script;
-            return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
-        }
-        return false;
-    }
-    canSignNonTaprootInput(input, publicKey) {
-        const script = this.getInputRelevantScript(input);
-        if (script) {
-            return this.pubkeyInScript(publicKey, script);
-        }
-        return false;
-    }
-    getInputRelevantScript(input) {
-        if (input.redeemScript) {
-            return input.redeemScript;
-        }
-        if (input.witnessScript) {
-            return input.witnessScript;
-        }
-        if (input.witnessUtxo) {
-            return input.witnessUtxo.script;
-        }
-        if (input.nonWitnessUtxo) {
-            return null;
-        }
-        return null;
-    }
-    pubkeyInScript(pubkey, script) {
-        return this.pubkeyPositionInScript(pubkey, script) !== -1;
-    }
-    pubkeyPositionInScript(pubkey, script) {
-        const pubkeyHash = bitCrypto.hash160(pubkey);
-        const pubkeyXOnly = toXOnly(pubkey);
-        const decompiled = bscript.decompile(script);
-        if (decompiled === null)
-            throw new Error('Unknown script error');
-        return decompiled.findIndex((element) => {
-            if (typeof element === 'number')
-                return false;
-            return (element.equals(pubkey) || element.equals(pubkeyHash) || element.equals(pubkeyXOnly));
-        });
-    }
     async signTaprootInput(signer, transaction, i, tapLeafHash) {
         if ('signTaprootInput' in signer) {
             try {