@btc-vision/transaction 1.1.1 → 1.1.3

package/src/transaction/shared/TweakedTransaction.ts

@@ -14,6 +14,7 @@ import {
     Signer,
     Transaction,
 } from '@btc-vision/bitcoin';
+
 import { TweakedSigner, TweakSettings } from '../../signer/TweakedSigner.js';
 import { ECPairInterface } from 'ecpair';
 import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
@@ -22,9 +23,11 @@ import { TapLeafScript } from '../interfaces/Tap.js';
 import { AddressTypes, AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { ChainId } from '../../network/ChainId.js';
 import { varuint } from '@btc-vision/bitcoin/src/bufferutils.js';
+import * as bscript from '@btc-vision/bitcoin/src/script.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 
 export interface ITweakedTransactionData {
-    readonly signer: Signer | ECPairInterface;
+    readonly signer: Signer | ECPairInterface | UnisatSigner;
     readonly network: Network;
     readonly chainId?: ChainId;
     readonly nonWitnessUtxo?: Buffer;
@@ -44,22 +47,27 @@ export enum TransactionSequence {
 export abstract class TweakedTransaction extends Logger {
     public readonly logColor: string = '#00ffe1';
     public finalized: boolean = false;
+
     /**
      * @description Was the transaction signed?
      */
-    protected signer: Signer | ECPairInterface;
+    protected signer: Signer | ECPairInterface | UnisatSigner;
+
     /**
      * @description Tweaked signer
      */
     protected tweakedSigner?: ECPairInterface;
+
     /**
      * @description The network of the transaction
      */
     protected network: Network;
+
     /**
      * @description Was the transaction signed?
      */
     protected signed: boolean = false;
+
     /**
      * @description The transaction
      * @protected
@@ -358,100 +366,54 @@ export abstract class TweakedTransaction extends Logger {
     /**
      * Signs an input of the transaction.
      * @param {Psbt} transaction - The transaction to sign
-     * @param {PsbtInput} _input - The input to sign
+     * @param {PsbtInput} input - The input to sign
      * @param {number} i - The index of the input
      * @param {Signer} signer - The signer to use
+     * @param {boolean} [reverse=false] - Should the input be signed in reverse
      * @protected
      */
     protected async signInput(
         transaction: Psbt,
-        _input: PsbtInput,
+        input: PsbtInput,
         i: number,
         signer: Signer | ECPairInterface,
+        reverse: boolean = false,
     ): Promise<void> {
-        try {
-            if ('signInput' in signer) {
-                // @ts-expect-error - we know it's a signer
-                return await (signer.signInput(transaction, i) as Promise<void>);
-            }
+        const publicKey = signer.publicKey;
+        let isTaproot = this.isTaprootInput(input);
 
-            transaction.signInput(i, signer);
-        } catch {
-            try {
-                if ('signTaprootInput' in signer) {
-                    // @ts-expect-error - we know it's a taproot signer
-                    return await (signer.signTaprootInput(transaction, i) as Promise<void>);
-                }
-
-                transaction.signTaprootInput(i, signer);
-            } catch {
-                throw new Error('Failed to sign input');
-            }
+        if (reverse) {
+            isTaproot = !isTaproot;
         }
 
-        /*const signHash =
-            this.sighashTypes && this.sighashTypes.length
-                ? [TweakedTransaction.calculateSignHash(this.sighashTypes)]
-                : undefined;
-
-        signer = signer || this.getSignerKey();
+        let signed: boolean = false;
 
-        let testedTap: boolean = false;
-        if (input.tapInternalKey) {
-            if (!this.tweakedSigner) this.tweakSigner();
-
-            let tweakedSigner: ECPairInterface | undefined;
-            if (signer !== this.signer) {
-                tweakedSigner = this.getTweakedSigner(true, signer);
-            } else {
-                tweakedSigner = this.tweakedSigner;
+        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}`);
             }
-
-            if (tweakedSigner) {
-                testedTap = true;
-
+        } else {
+            // Non-Taproot input
+            if (!reverse ? this.canSignNonTaprootInput(input, publicKey) : true) {
                 try {
-                    if ('signTaprootInput' in signer) {
-                        // @ts-expect-error - we know it's a taproot signer
-                        return await (signer.signTaprootInput(
-                            transaction,
-                            i,
-                            signHash,
-                        ) as Promise<void>);
-                    } else {
-                        transaction.signTaprootInput(i, tweakedSigner, undefined, signHash);
-                    }
-
-                    return;
-                } catch {}
+                    await this.signNonTaprootInput(signer, transaction, i);
+                    signed = true;
+                } catch (e) {
+                    this.error(`Failed to sign non-Taproot input ${i}: ${e}`);
+                }
             }
         }
 
-        try {
-            if ('signInput' in signer) {
-                // @ts-expect-error - we know it's a signer
-                return await (signer.signInput(transaction, i, signHash) as Promise<void>);
-            } else {
-                transaction.signInput(i, signer, signHash);
-            }
-        } catch (e) {
-            if (!testedTap) {
-                // and we try again taproot...
-
-                if ('signTaprootInput' in signer) {
-                    // @ts-expect-error - we know it's a taproot signer
-                    return await (signer.signTaprootInput(
-                        transaction,
-                        i,
-                        signHash,
-                    ) as Promise<void>);
-                } else if (this.tweakedSigner) {
-                    transaction.signTaprootInput(i, this.tweakedSigner, undefined, signHash);
-                } else {
-                    throw e;
-                }
+        if (!signed) {
+            try {
+                await this.signInput(transaction, input, i, signer, true);
+            } catch {
+                throw new Error(`Cannot sign input ${i} with the provided signer.`);
             }
-        }*/
+        }
     }
 
     protected splitArray<T>(arr: T[], chunkSize: number): T[][] {
@@ -460,7 +422,6 @@ export abstract class TweakedTransaction extends Logger {
         }
 
         const result: T[][] = [];
-
         for (let i = 0; i < arr.length; i += chunkSize) {
             result.push(arr.slice(i, i + chunkSize));
         }
@@ -475,6 +436,12 @@ export abstract class TweakedTransaction extends Logger {
      * @returns {Promise<void>}
      */
     protected async signInputs(transaction: Psbt): Promise<void> {
+        if ('multiSignPsbt' in this.signer) {
+            await this.signInputsWalletBased(transaction);
+            return;
+        }
+
+        // non web based signing.
         const txs: PsbtInput[] = transaction.data.inputs;
 
         const batchSize: number = 20;
@@ -499,15 +466,11 @@ export abstract class TweakedTransaction extends Logger {
             await Promise.all(promises);
         }
 
-        transaction.finalizeInput(0, this.customFinalizerP2SH);
-
-        try {
-            transaction.finalizeAllInputs();
-
-            this.finalized = true;
-        } catch (e) {
-            this.finalized = false;
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            transaction.finalizeInput(i, this.customFinalizerP2SH);
         }
+
+        this.finalized = true;
     }
 
     /**
@@ -698,10 +661,9 @@ export abstract class TweakedTransaction extends Logger {
 
         if (i === 0 && this.nonWitnessUtxo) {
             input.nonWitnessUtxo = this.nonWitnessUtxo;
-            this.log(`Using non-witness utxo for input ${i}`);
         }
 
-        // automatically detect p2tr inputs.
+        // Automatically detect P2TR inputs.
         if (
             utxo.scriptPubKey.address &&
             AddressVerificator.isValidP2TRAddress(utxo.scriptPubKey.address, this.network)
@@ -715,11 +677,11 @@ export abstract class TweakedTransaction extends Logger {
     }
 
     protected customFinalizerP2SH = (
-        inputIndex: number, // Which input is it?
-        input: PsbtInput, // The PSBT input contents
-        scriptA: Buffer, // The "meaningful" locking script Buffer (redeemScript for P2SH etc.)
-        isSegwit: boolean, // Is it segwit?
-        isP2SH: boolean, // Is it P2SH?
+        inputIndex: number,
+        input: PsbtInput,
+        scriptA: Buffer,
+        isSegwit: boolean,
+        isP2SH: boolean,
         isP2WSH: boolean,
     ): {
         finalScriptSig: Buffer | undefined;
@@ -728,31 +690,166 @@ export abstract class TweakedTransaction extends Logger {
         const inputDecoded = this.inputs[inputIndex];
         if (isP2SH && input.partialSig && inputDecoded && inputDecoded.redeemScript) {
             const signatures = input.partialSig.map((sig) => sig.signature);
-
-            /*const fakeSignature = Buffer.from([
-                0x30,
-                0x45, // DER prefix: 0x30 (Compound), 0x45 (length = 69 bytes)
-                0x02,
-                0x20, // Integer marker: 0x02 (integer), 0x20 (length = 32 bytes)
-                ...Buffer.alloc(32, 0x00), // 32-byte fake 'r' value (all zeros)
-                0x02,
-                0x21, // Integer marker: 0x02 (integer), 0x21 (length = 33 bytes)
-                ...Buffer.alloc(33, 0x00), // 33-byte fake 's' value (all zeros)
-                0x01, // SIGHASH_ALL flag (0x01)
-            ]);*/
-
-            const scriptSig = script.compile([
-                ...signatures,
-                //fakeSignature,
-                inputDecoded.redeemScript,
-            ]);
+            const scriptSig = script.compile([...signatures, inputDecoded.redeemScript]);
 
             return {
-                finalScriptSig: scriptSig, // Manually set the final scriptSig
-                finalScriptWitness: undefined, // Manually set the final scriptWitness
+                finalScriptSig: scriptSig,
+                finalScriptWitness: undefined,
             };
         }
 
         return getFinalScripts(inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH);
     };
+
+    protected async signInputsWalletBased(transaction: Psbt): Promise<void> {
+        const signer: UnisatSigner = this.signer as UnisatSigner;
+
+        // then, we sign all the remaining inputs with the wallet signer.
+        await signer.multiSignPsbt([transaction]);
+
+        // Then, we finalize every input.
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            transaction.finalizeInput(i, this.customFinalizerP2SH);
+        }
+
+        this.finalized = true;
+    }
+
+    private async attemptSignTaproot(
+        transaction: Psbt,
+        input: PsbtInput,
+        i: number,
+        signer: Signer | ECPairInterface,
+        publicKey: Buffer,
+    ): Promise<void> {
+        const isScriptSpend = this.isTaprootScriptSpend(input, publicKey);
+
+        if (isScriptSpend) {
+            await this.signTaprootInput(signer, transaction, i);
+        } else {
+            let tweakedSigner: ECPairInterface | undefined;
+            if (signer !== this.signer) {
+                tweakedSigner = this.getTweakedSigner(true, signer);
+            } else {
+                if (!this.tweakedSigner) this.tweakSigner();
+                tweakedSigner = this.tweakedSigner;
+            }
+
+            if (tweakedSigner) {
+                await this.signTaprootInput(tweakedSigner, transaction, i);
+            } else {
+                this.error(`Failed to obtain tweaked signer for input ${i}.`);
+            }
+        }
+    }
+
+    private isTaprootScriptSpend(input: PsbtInput, publicKey: Buffer): boolean {
+        if (input.tapLeafScript && input.tapLeafScript.length > 0) {
+            // Check if the signer's public key is involved in any tapLeafScript
+            for (const tapLeafScript of input.tapLeafScript) {
+                if (this.pubkeyInScript(publicKey, tapLeafScript.script)) {
+                    // The public key is in the script; it's a script spend
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // Helper method to determine if an input is Taproot
+    private isTaprootInput(input: PsbtInput): boolean {
+        if (input.tapInternalKey || input.tapKeySig || input.tapScriptSig || input.tapLeafScript) {
+            return true;
+        }
+
+        if (input.witnessUtxo) {
+            const script = input.witnessUtxo.script;
+            // Check if the script is a P2TR output (OP_1 [32-byte key])
+            return script.length === 34 && script[0] === opcodes.OP_1 && script[1] === 0x20;
+        }
+
+        return false;
+    }
+
+    // Check if the signer can sign the non-Taproot input
+    private canSignNonTaprootInput(input: PsbtInput, publicKey: Buffer): boolean {
+        const script = this.getInputRelevantScript(input);
+        if (script) {
+            return this.pubkeyInScript(publicKey, script);
+        }
+        return false;
+    }
+
+    // Helper method to extract the relevant script from the input
+    private getInputRelevantScript(input: PsbtInput): Buffer | null {
+        if (input.redeemScript) {
+            return input.redeemScript;
+        }
+        if (input.witnessScript) {
+            return input.witnessScript;
+        }
+        if (input.witnessUtxo) {
+            return input.witnessUtxo.script;
+        }
+        if (input.nonWitnessUtxo) {
+            // Additional logic can be added to extract script from nonWitnessUtxo
+            return null;
+        }
+        return null;
+    }
+
+    // Helper method to check if a public key is in a script
+    private pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+        return this.pubkeyPositionInScript(pubkey, script) !== -1;
+    }
+
+    private pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
+        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)
+            );
+        });
+    }
+
+    private async signTaprootInput(
+        signer: Signer | ECPairInterface,
+        transaction: Psbt,
+        i: number,
+        tapLeafHash?: Buffer,
+    ): Promise<void> {
+        if ('signTaprootInput' in signer) {
+            try {
+                await (
+                    signer.signTaprootInput as (
+                        tx: Psbt,
+                        i: number,
+                        tapLeafHash?: Buffer,
+                    ) => Promise<void>
+                )(transaction, i, tapLeafHash);
+            } catch {
+                throw new Error('Failed to sign Taproot input with provided signer.');
+            }
+        } else {
+            transaction.signTaprootInput(i, signer); //tapLeafHash
+        }
+    }
+
+    private async signNonTaprootInput(
+        signer: Signer | ECPairInterface,
+        transaction: Psbt,
+        i: number,
+    ): Promise<void> {
+        if ('signInput' in signer) {
+            await (signer.signInput as (tx: Psbt, i: number) => Promise<void>)(transaction, i);
+        } else {
+            transaction.signInput(i, signer);
+        }
+    }
 }