@btc-vision/transaction 1.1.2 → 1.1.3

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

package/src/transaction/shared/TweakedTransaction.ts

@@ -24,9 +24,10 @@ import { AddressTypes, AddressVerificator } from '../../keypair/AddressVerificat
 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;
@@ -46,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
@@ -363,6 +369,7 @@ export abstract class TweakedTransaction extends Logger {
      * @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(
@@ -370,45 +377,27 @@ export abstract class TweakedTransaction extends Logger {
         input: PsbtInput,
         i: number,
         signer: Signer | ECPairInterface,
+        reverse: boolean = false,
     ): Promise<void> {
         const publicKey = signer.publicKey;
-        const isTaproot = this.isTaprootInput(input);
+        let isTaproot = this.isTaprootInput(input);
 
-        let signed = false;
+        if (reverse) {
+            isTaproot = !isTaproot;
+        }
 
-        if (isTaproot) {
-            const isScriptSpend = this.isTaprootScriptSpend(input, publicKey);
+        let signed: boolean = false;
 
-            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 {
-                let tweakedSigner: ECPairInterface | undefined;
-                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;
-                    } catch (e) {
-                        this.error(`Failed to sign Taproot key path input ${i}: ${e}`);
-                    }
-                } else {
-                    this.error(`Failed to obtain tweaked signer for input ${i}.`);
-                }
+        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}`);
             }
         } else {
             // Non-Taproot input
-            if (this.canSignNonTaprootInput(input, publicKey)) {
+            if (!reverse ? this.canSignNonTaprootInput(input, publicKey) : true) {
                 try {
                     await this.signNonTaprootInput(signer, transaction, i);
                     signed = true;
@@ -419,7 +408,11 @@ export abstract class TweakedTransaction extends Logger {
         }
 
         if (!signed) {
-            throw new Error(`Cannot sign input ${i} with the provided signer.`);
+            try {
+                await this.signInput(transaction, input, i, signer, true);
+            } catch {
+                throw new Error(`Cannot sign input ${i} with the provided signer.`);
+            }
         }
     }
 
@@ -443,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;
@@ -467,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;
     }
 
     /**
@@ -706,6 +701,48 @@ export abstract class TweakedTransaction extends Logger {
         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
@@ -788,13 +825,17 @@ export abstract class TweakedTransaction extends Logger {
         tapLeafHash?: Buffer,
     ): Promise<void> {
         if ('signTaprootInput' in signer) {
-            await (
-                signer.signTaprootInput as (
-                    tx: Psbt,
-                    i: number,
-                    tapLeafHash?: Buffer,
-                ) => Promise<void>
-            )(transaction, i, tapLeafHash);
+            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
         }