@btc-vision/transaction 1.1.1 → 1.1.3

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,
@@ -156,22 +154,39 @@ export class TweakedTransaction extends Logger {
     getSignerKey() {
         return this.signer;
     }
-    async signInput(transaction, _input, i, signer) {
-        try {
-            if ('signInput' in signer) {
-                return await signer.signInput(transaction, i);
-            }
-            transaction.signInput(i, signer);
+    async signInput(transaction, input, i, signer, reverse = false) {
+        const publicKey = signer.publicKey;
+        let isTaproot = this.isTaprootInput(input);
+        if (reverse) {
+            isTaproot = !isTaproot;
         }
-        catch {
+        let signed = false;
+        if (isTaproot) {
             try {
-                if ('signTaprootInput' in signer) {
-                    return await signer.signTaprootInput(transaction, i);
+                await this.attemptSignTaproot(transaction, input, i, signer, publicKey);
+                signed = true;
+            }
+            catch (e) {
+                this.error(`Failed to sign Taproot script path input ${i}: ${e}`);
+            }
+        }
+        else {
+            if (!reverse ? this.canSignNonTaprootInput(input, publicKey) : true) {
+                try {
+                    await this.signNonTaprootInput(signer, transaction, i);
+                    signed = true;
                 }
-                transaction.signTaprootInput(i, signer);
+                catch (e) {
+                    this.error(`Failed to sign non-Taproot input ${i}: ${e}`);
+                }
+            }
+        }
+        if (!signed) {
+            try {
+                await this.signInput(transaction, input, i, signer, true);
             }
             catch {
-                throw new Error('Failed to sign input');
+                throw new Error(`Cannot sign input ${i} with the provided signer.`);
             }
         }
     }
@@ -186,6 +201,10 @@ export class TweakedTransaction extends Logger {
         return result;
     }
     async signInputs(transaction) {
+        if ('multiSignPsbt' in this.signer) {
+            await this.signInputsWalletBased(transaction);
+            return;
+        }
         const txs = transaction.data.inputs;
         const batchSize = 20;
         const batches = this.splitArray(txs, batchSize);
@@ -205,14 +224,10 @@ export 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;
     }
     internalPubKeyToXOnly() {
         return toXOnly(Buffer.from(this.signer.publicKey));
@@ -332,7 +347,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)) {
@@ -341,4 +355,113 @@ export class TweakedTransaction extends Logger {
         }
         return input;
     }
+    async signInputsWalletBased(transaction) {
+        const signer = this.signer;
+        await signer.multiSignPsbt([transaction]);
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            transaction.finalizeInput(i, this.customFinalizerP2SH);
+        }
+        this.finalized = true;
+    }
+    async attemptSignTaproot(transaction, input, i, signer, publicKey) {
+        const isScriptSpend = this.isTaprootScriptSpend(input, publicKey);
+        if (isScriptSpend) {
+            await this.signTaprootInput(signer, transaction, i);
+        }
+        else {
+            let tweakedSigner;
+            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}.`);
+            }
+        }
+    }
+    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) {
+            try {
+                await signer.signTaprootInput(transaction, i, tapLeafHash);
+            }
+            catch {
+                throw new Error('Failed to sign Taproot input with provided signer.');
+            }
+        }
+        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.1",
+    "version": "1.1.3",
     "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.1';
+export const version = '1.1.3';

package/src/buffer/BinaryWriter.ts

@@ -63,8 +63,6 @@ export class BinaryWriter {
 
         const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
         if (bytesToHex.byteLength !== 32) {
-            console.log('Invalid u256 value:', bytesToHex);
-
             throw new Error(`Invalid u256 value: ${bigIntValue}`);
         }
 

package/src/transaction/browser/extensions/UnisatSigner.ts

@@ -1,9 +1,19 @@
-import { Network, networks, Psbt, TapScriptSig } from '@btc-vision/bitcoin';
+import {
+    crypto as bitCrypto,
+    Network,
+    networks,
+    opcodes,
+    Psbt,
+    PsbtInput,
+    script as bitScript,
+    TapScriptSig,
+} from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
 import { EcKeyPair } from '../../../keypair/EcKeyPair.js';
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions, Unisat, UnisatNetwork } from '../types/Unisat.js';
 import { PartialSig } from 'bip174/src/lib/interfaces.js';
+import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
 
 declare global {
     interface Window {
@@ -122,15 +132,15 @@ export class UnisatSigner extends CustomKeypair {
         return this.publicKey;
     }
 
-    public sign(hash: Buffer, lowR?: boolean): Buffer {
+    public sign(_hash: Buffer, _lowR?: boolean): Buffer {
         throw new Error('Not implemented: sign');
     }
 
-    public signSchnorr(hash: Buffer): Buffer {
+    public signSchnorr(_hash: Buffer): Buffer {
         throw new Error('Not implemented: signSchnorr');
     }
 
-    public verify(hash: Buffer, signature: Buffer): boolean {
+    public verify(_hash: Buffer, _signature: Buffer): boolean {
         throw new Error('Not implemented: verify');
     }
 
@@ -176,6 +186,80 @@ export class UnisatSigner extends CustomKeypair {
         this.combine(transaction, firstSignature, i);
     }
 
+    public async multiSignPsbt(transactions: Psbt[]): Promise<void> {
+        const toSignPsbts: string[] = [];
+        const options: PsbtSignatureOptions[] = [];
+
+        for (const psbt of transactions) {
+            const hex = psbt.toHex();
+            toSignPsbts.push(hex);
+
+            const toSignInputs = psbt.data.inputs
+                .map((input, i) => {
+                    let needsToSign = false;
+                    let viaTaproot = false;
+
+                    if (isTaprootInput(input)) {
+                        if (input.tapLeafScript && input.tapLeafScript.length > 0) {
+                            for (const tapLeafScript of input.tapLeafScript) {
+                                if (pubkeyInScript(this.publicKey, tapLeafScript.script)) {
+                                    needsToSign = true;
+                                    viaTaproot = false; // for opnet, we use original keys.
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (!needsToSign && input.tapInternalKey) {
+                            const tapInternalKey = input.tapInternalKey;
+                            const xOnlyPubKey = toXOnly(this.publicKey);
+
+                            if (tapInternalKey.equals(xOnlyPubKey)) {
+                                needsToSign = true;
+                                viaTaproot = true;
+                            }
+                        }
+                    } else {
+                        // Non-Taproot input
+                        const script = getInputRelevantScript(input);
+
+                        if (script && pubkeyInScript(this.publicKey, script)) {
+                            needsToSign = true;
+                            viaTaproot = false;
+                        }
+                    }
+
+                    if (needsToSign) {
+                        return {
+                            index: i,
+                            publicKey: this.publicKey.toString('hex'),
+                            disableTweakSigner: !viaTaproot,
+                        };
+                    } else {
+                        return null;
+                    }
+                })
+                .filter((v) => v !== null);
+
+            options.push({
+                autoFinalized: false,
+                toSignInputs: toSignInputs,
+            });
+        }
+
+        const signed = await this.unisat.signPsbt(toSignPsbts[0], options[0]);
+        const signedPsbts = Psbt.fromHex(signed); //signed.map((hex) => Psbt.fromHex(hex));
+
+        /*for (let i = 0; i < signedPsbts.length; i++) {
+            const psbtOriginal = transactions[i];
+            const psbtSigned = signedPsbts[i];
+
+            psbtOriginal.combine(psbtSigned);
+        }*/
+
+        transactions[0].combine(signedPsbts);
+    }
+
     private hasAlreadySignedTapScriptSig(input: TapScriptSig[]): boolean {
         for (let i = 0; i < input.length; i++) {
             const item = input[i];
@@ -257,30 +341,6 @@ export class UnisatSigner extends CustomKeypair {
         return Psbt.fromHex(signed);
     }
 
-    private async signTweaked(
-        transaction: Psbt,
-        i: number,
-        sighashTypes: number[],
-        disableTweakSigner: boolean = false,
-    ): Promise<Psbt> {
-        const opts: PsbtSignatureOptions = {
-            autoFinalized: false,
-            toSignInputs: [
-                {
-                    index: i,
-                    publicKey: this.publicKey.toString('hex'),
-                    sighashTypes,
-                    disableTweakSigner: disableTweakSigner,
-                },
-            ],
-        };
-
-        const psbt = transaction.toHex();
-        const signed = await this.unisat.signPsbt(psbt, opts);
-
-        return Psbt.fromHex(signed);
-    }
-
     private getNonDuplicateScriptSig(
         scriptSig1: TapScriptSig[],
         scriptSig2: TapScriptSig[],
@@ -296,3 +356,54 @@ export class UnisatSigner extends CustomKeypair {
         return nonDuplicate;
     }
 }
+
+// Helper functions
+function isTaprootInput(input: PsbtInput): boolean {
+    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: 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 here if needed
+        return null;
+    }
+    return null;
+}
+
+function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}
+
+function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
+    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/src/transaction/browser/types/Unisat.ts

@@ -83,7 +83,7 @@ export interface Unisat {
 
     signPsbt(psbtHex: string, psbtOptions: PsbtSignatureOptions): Promise<string>;
 
-    signPsbts(psbtHex: string[], psbtOptions: PsbtSignatureOptions): Promise<string[]>;
+    signPsbts(psbtHex: string[], psbtOptions: PsbtSignatureOptions[]): Promise<string[]>;
 
     pushPsbt(psbtHex: string): Promise<string>;
 

package/src/transaction/builders/DeploymentTransaction.ts

@@ -12,6 +12,7 @@ import { Compressor } from '../../bytecode/Compressor.js';
 import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
 import { ECPairInterface } from 'ecpair';
 import { Address } from '../../keypair/Address.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
@@ -203,6 +204,25 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         await this.addRefundOutput(amountSpent);
     }
 
+    protected override async signInputsWalletBased(transaction: Psbt): Promise<void> {
+        const signer: UnisatSigner = this.signer as UnisatSigner;
+
+        // first, we sign the first input with the script signer.
+        await this.signInput(transaction, transaction.data.inputs[0], 0, this.contractSigner);
+
+        // 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++) {
+            if (i === 0) {
+                transaction.finalizeInput(i, this.customFinalizer);
+            } else {
+                transaction.finalizeInput(i);
+            }
+        }
+    }
+
     /**
      * Sign the inputs
      * @param {Psbt} transaction The transaction to sign
@@ -215,6 +235,11 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             return;
         }
 
+        if ('multiSignPsbt' in this.signer) {
+            await this.signInputsWalletBased(transaction);
+            return;
+        }
+
         for (let i = 0; i < transaction.data.inputs.length; i++) {
             if (i === 0) {
                 // multi sig input

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -9,6 +9,7 @@ import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
 import { toXOnly } from '@btc-vision/bitcoin/src/psbt/bip371.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 
 /**
  * Shared interaction transaction
@@ -186,27 +187,10 @@ export abstract class SharedInteractionTransaction<
             return;
         }
 
-        for (let i = 0; i < transaction.data.inputs.length; i++) {
-            if (i === 0) {
-                await this.signInput(transaction, transaction.data.inputs[i], i, this.scriptSigner);
-                await this.signInput(
-                    transaction,
-                    transaction.data.inputs[i],
-                    i,
-                    this.getSignerKey(),
-                );
-
-                transaction.finalizeInput(i, this.customFinalizer);
-            } else {
-                await this.signInput(
-                    transaction,
-                    transaction.data.inputs[i],
-                    i,
-                    this.getSignerKey(),
-                );
-
-                transaction.finalizeInput(i);
-            }
+        if ('multiSignPsbt' in this.signer) {
+            await this.signInputsWalletBased(transaction);
+        } else {
+            await this.signInputsNonWalletBased(transaction);
         }
     }
 
@@ -308,6 +292,52 @@ export abstract class SharedInteractionTransaction<
         };
     };
 
+    // custom for interactions
+    protected override async signInputsWalletBased(transaction: Psbt): Promise<void> {
+        const signer: UnisatSigner = this.signer as UnisatSigner;
+
+        // first, we sign the first input with the script signer.
+        await this.signInput(transaction, transaction.data.inputs[0], 0, this.scriptSigner);
+
+        // 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++) {
+            if (i === 0) {
+                transaction.finalizeInput(i, this.customFinalizer);
+            } else {
+                transaction.finalizeInput(i);
+            }
+        }
+    }
+
+    private async signInputsNonWalletBased(transaction: Psbt): Promise<void> {
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (i === 0) {
+                await this.signInput(transaction, transaction.data.inputs[i], i, this.scriptSigner);
+
+                await this.signInput(
+                    transaction,
+                    transaction.data.inputs[i],
+                    i,
+                    this.getSignerKey(),
+                );
+
+                transaction.finalizeInput(i, this.customFinalizer);
+            } else {
+                await this.signInput(
+                    transaction,
+                    transaction.data.inputs[i],
+                    i,
+                    this.getSignerKey(),
+                );
+
+                transaction.finalizeInput(i);
+            }
+        }
+    }
+
     /**
      * Get the public keys
      * @private

package/src/transaction/builders/TransactionBuilder.ts

@@ -22,6 +22,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ECPairInterface } from 'ecpair';
 import { AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 
 initEccLib(ecc);
 
@@ -91,7 +92,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
     /**
      * @description The signer of the transaction
      */
-    protected readonly signer: Signer | ECPairInterface;
+    protected readonly signer: Signer | ECPairInterface | UnisatSigner;
 
     /**
      * @description The network where the transaction will be broadcasted