@btc-vision/transaction 1.1.0 → 1.1.2

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

@@ -47,7 +47,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): Promise<void>;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface): Promise<void>;
     protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
@@ -64,4 +64,12 @@ export declare abstract class TweakedTransaction extends Logger {
         finalScriptSig: Buffer | undefined;
         finalScriptWitness: Buffer | undefined;
     };
+    private isTaprootScriptSpend;
+    private isTaprootInput;
+    private canSignNonTaprootInput;
+    private getInputRelevantScript;
+    private pubkeyInScript;
+    private pubkeyPositionInScript;
+    private signTaprootInput;
+    private signNonTaprootInput;
 }

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.1.0";
+export declare const version = "1.1.2";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.1.0';
+export const version = '1.1.2';

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

@@ -47,7 +47,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): Promise<void>;
+    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface): Promise<void>;
     protected splitArray<T>(arr: T[], chunkSize: number): T[][];
     protected signInputs(transaction: Psbt): Promise<void>;
     protected internalPubKeyToXOnly(): Buffer;
@@ -64,4 +64,12 @@ export declare abstract class TweakedTransaction extends Logger {
         finalScriptSig: Buffer | undefined;
         finalScriptWitness: Buffer | undefined;
     };
+    private isTaprootScriptSpend;
+    private isTaprootInput;
+    private canSignNonTaprootInput;
+    private getInputRelevantScript;
+    private pubkeyInScript;
+    private pubkeyPositionInScript;
+    private signTaprootInput;
+    private signNonTaprootInput;
 }

package/build/transaction/shared/TweakedTransaction.js

@@ -4,6 +4,7 @@ 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';
 export var TransactionSequence;
 (function (TransactionSequence) {
     TransactionSequence[TransactionSequence["REPLACE_BY_FEE"] = 4294967293] = "REPLACE_BY_FEE";
@@ -27,10 +28,7 @@ export 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 scriptSig = script.compile([
-                    ...signatures,
-                    inputDecoded.redeemScript,
-                ]);
+                const scriptSig = script.compile([...signatures, inputDecoded.redeemScript]);
                 return {
                     finalScriptSig: scriptSig,
                     finalScriptWitness: undefined,
@@ -157,56 +155,58 @@ export class TweakedTransaction extends Logger {
         return this.signer;
     }
     async signInput(transaction, input, i, signer) {
-        const signHash = this.sighashTypes && this.sighashTypes.length
-            ? [TweakedTransaction.calculateSignHash(this.sighashTypes)]
-            : undefined;
-        signer = signer || this.getSignerKey();
-        let testedTap = false;
-        if (input.tapInternalKey) {
-            if (!this.tweakedSigner)
-                this.tweakSigner();
-            let tweakedSigner;
-            if (signer !== this.signer) {
-                tweakedSigner = this.getTweakedSigner(true, signer);
+        const publicKey = signer.publicKey;
+        const isTaproot = this.isTaprootInput(input);
+        let signed = false;
+        if (isTaproot) {
+            const isScriptSpend = this.isTaprootScriptSpend(input, publicKey);
+            if (isScriptSpend) {
+                try {
+                    await this.signTaprootInput(signer, transaction, i);
+                    signed = true;
+                }
+                catch (e) {
+                    this.error(`Failed to sign Taproot script path input ${i}: ${e}`);
+                }
             }
             else {
-                tweakedSigner = this.tweakedSigner;
-            }
-            if (tweakedSigner) {
-                testedTap = true;
-                try {
-                    if ('signTaprootInput' in signer) {
-                        return await signer.signTaprootInput(transaction, i, signHash);
+                let tweakedSigner;
+                if (signer !== this.signer) {
+                    tweakedSigner = this.getTweakedSigner(true, signer);
+                }
+                else {
+                    if (!this.tweakedSigner)
+                        this.tweakSigner();
+                    tweakedSigner = this.tweakedSigner;
+                }
+                if (tweakedSigner) {
+                    try {
+                        await this.signTaprootInput(tweakedSigner, transaction, i);
+                        signed = true;
                     }
-                    else {
-                        transaction.signTaprootInput(i, tweakedSigner, undefined, signHash);
+                    catch (e) {
+                        this.error(`Failed to sign Taproot key path input ${i}: ${e}`);
                     }
-                    return;
                 }
-                catch { }
-            }
-        }
-        try {
-            if ('signInput' in signer) {
-                return await signer.signInput(transaction, i, signHash);
-            }
-            else {
-                transaction.signInput(i, signer, signHash);
+                else {
+                    this.error(`Failed to obtain tweaked signer for input ${i}.`);
+                }
             }
         }
-        catch (e) {
-            if (!testedTap) {
-                if ('signTaprootInput' in signer) {
-                    return await signer.signTaprootInput(transaction, i, signHash);
-                }
-                else if (this.tweakedSigner) {
-                    transaction.signTaprootInput(i, this.tweakedSigner, undefined, signHash);
+        else {
+            if (this.canSignNonTaprootInput(input, publicKey)) {
+                try {
+                    await this.signNonTaprootInput(signer, transaction, i);
+                    signed = true;
                 }
-                else {
-                    throw e;
+                catch (e) {
+                    this.error(`Failed to sign non-Taproot input ${i}: ${e}`);
                 }
             }
         }
+        if (!signed) {
+            throw new Error(`Cannot sign input ${i} with the provided signer.`);
+        }
     }
     splitArray(arr, chunkSize) {
         if (chunkSize <= 0) {
@@ -230,7 +230,7 @@ export class TweakedTransaction extends Logger {
                 const index = offset + j;
                 const input = batch[j];
                 try {
-                    promises.push(this.signInput(transaction, input, index));
+                    promises.push(this.signInput(transaction, input, index, this.signer));
                 }
                 catch (e) {
                     this.log(`Failed to sign input ${index}: ${e.stack}`);
@@ -365,7 +365,6 @@ export class TweakedTransaction extends Logger {
         }
         if (i === 0 && this.nonWitnessUtxo) {
             input.nonWitnessUtxo = this.nonWitnessUtxo;
-            this.log(`Using non-witness utxo for input ${i}`);
         }
         if (utxo.scriptPubKey.address &&
             AddressVerificator.isValidP2TRAddress(utxo.scriptPubKey.address, this.network)) {
@@ -374,4 +373,77 @@ export class TweakedTransaction extends Logger {
         }
         return input;
     }
+    isTaprootScriptSpend(input, publicKey) {
+        if (input.tapLeafScript && input.tapLeafScript.length > 0) {
+            for (const tapLeafScript of input.tapLeafScript) {
+                if (this.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) {
+            await signer.signTaprootInput(transaction, i, tapLeafHash);
+        }
+        else {
+            transaction.signTaprootInput(i, signer);
+        }
+    }
+    async signNonTaprootInput(signer, transaction, i) {
+        if ('signInput' in signer) {
+            await signer.signInput(transaction, i);
+        }
+        else {
+            transaction.signInput(i, signer);
+        }
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.1.0",
+    "version": "1.1.2",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -63,6 +63,9 @@
         "browserBuild": "webpack --mode production",
         "docs": "typedoc --out docs --exclude 'src/tests/*.ts' --tsconfig tsconfig.json --readme README.md --name OPNet --plugin typedoc-material-theme --themeColor '#cb9820' --exclude src/tests/test.ts --exclude src/index.ts src"
     },
+    "peerDependencies": {
+        "@btc-vision/bitcoin": "^6.3.0"
+    },
     "devDependencies": {
         "@babel/core": "^7.26.0",
         "@babel/plugin-proposal-class-properties": "^7.18.6",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.1.0';
+export const version = '1.1.2';

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,6 +23,7 @@ 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';
 
 export interface ITweakedTransactionData {
     readonly signer: Signer | ECPairInterface;
@@ -360,78 +362,65 @@ export abstract class TweakedTransaction extends Logger {
      * @param {Psbt} transaction - The transaction 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 {Signer} signer - The signer to use
      * @protected
      */
     protected async signInput(
         transaction: Psbt,
         input: PsbtInput,
         i: number,
-        signer?: Signer | ECPairInterface,
+        signer: Signer | ECPairInterface,
     ): Promise<void> {
-        const signHash =
-            this.sighashTypes && this.sighashTypes.length
-                ? [TweakedTransaction.calculateSignHash(this.sighashTypes)]
-                : undefined;
+        const publicKey = signer.publicKey;
+        const isTaproot = this.isTaprootInput(input);
 
-        signer = signer || this.getSignerKey();
+        let signed = false;
 
-        let testedTap: boolean = false;
-        if (input.tapInternalKey) {
-            if (!this.tweakedSigner) this.tweakSigner();
+        if (isTaproot) {
+            const isScriptSpend = this.isTaprootScriptSpend(input, publicKey);
 
-            let tweakedSigner: ECPairInterface | undefined;
-            if (signer !== this.signer) {
-                tweakedSigner = this.getTweakedSigner(true, signer);
+            if (isScriptSpend) {
+                try {
+                    await this.signTaprootInput(signer, transaction, i);
+                    signed = true;
+                } catch (e) {
+                    this.error(`Failed to sign Taproot script path input ${i}: ${e}`);
+                }
             } else {
-                tweakedSigner = this.tweakedSigner;
-            }
-
-            if (tweakedSigner) {
-                testedTap = true;
+                let tweakedSigner: ECPairInterface | undefined;
+                if (signer !== this.signer) {
+                    tweakedSigner = this.getTweakedSigner(true, signer);
+                } else {
+                    if (!this.tweakedSigner) this.tweakSigner();
+                    tweakedSigner = this.tweakedSigner;
+                }
 
-                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);
+                if (tweakedSigner) {
+                    try {
+                        await this.signTaprootInput(tweakedSigner, transaction, i);
+                        signed = true;
+                    } catch (e) {
+                        this.error(`Failed to sign Taproot key path input ${i}: ${e}`);
                     }
-
-                    return;
-                } catch {}
-            }
-        }
-
-        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;
+                    this.error(`Failed to obtain tweaked signer for input ${i}.`);
+                }
+            }
+        } else {
+            // Non-Taproot input
+            if (this.canSignNonTaprootInput(input, publicKey)) {
+                try {
+                    await this.signNonTaprootInput(signer, transaction, i);
+                    signed = true;
+                } catch (e) {
+                    this.error(`Failed to sign non-Taproot input ${i}: ${e}`);
                 }
             }
         }
+
+        if (!signed) {
+            throw new Error(`Cannot sign input ${i} with the provided signer.`);
+        }
     }
 
     protected splitArray<T>(arr: T[], chunkSize: number): T[][] {
@@ -440,7 +429,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));
         }
@@ -470,7 +458,7 @@ export abstract class TweakedTransaction extends Logger {
                 const input = batch[j];
 
                 try {
-                    promises.push(this.signInput(transaction, input, index));
+                    promises.push(this.signInput(transaction, input, index, this.signer));
                 } catch (e) {
                     this.log(`Failed to sign input ${index}: ${(e as Error).stack}`);
                 }
@@ -678,10 +666,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)
@@ -695,11 +682,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;
@@ -708,31 +695,120 @@ 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);
     };
+
+    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) {
+            await (
+                signer.signTaprootInput as (
+                    tx: Psbt,
+                    i: number,
+                    tapLeafHash?: Buffer,
+                ) => Promise<void>
+            )(transaction, i, tapLeafHash);
+        } 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);
+        }
+    }
 }