@btc-vision/transaction 1.1.2 → 1.1.4

package/build/transaction/shared/TweakedTransaction.js

@@ -154,47 +154,24 @@ export class TweakedTransaction extends Logger {
     getSignerKey() {
         return this.signer;
     }
-    async signInput(transaction, input, i, signer) {
+    async signInput(transaction, input, i, signer, reverse = false) {
         const publicKey = signer.publicKey;
-        const isTaproot = this.isTaprootInput(input);
+        let isTaproot = this.isTaprootInput(input);
+        if (reverse) {
+            isTaproot = !isTaproot;
+        }
         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}`);
-                }
+            try {
+                await this.attemptSignTaproot(transaction, input, i, signer, publicKey);
+                signed = true;
             }
-            else {
-                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;
-                    }
-                    catch (e) {
-                        this.error(`Failed to sign Taproot key path input ${i}: ${e}`);
-                    }
-                }
-                else {
-                    this.error(`Failed to obtain tweaked signer for input ${i}.`);
-                }
+            catch (e) {
+                this.error(`Failed to sign Taproot script path input ${i}: ${e}`);
             }
         }
         else {
-            if (this.canSignNonTaprootInput(input, publicKey)) {
+            if (!reverse ? this.canSignNonTaprootInput(input, publicKey) : true) {
                 try {
                     await this.signNonTaprootInput(signer, transaction, i);
                     signed = true;
@@ -205,7 +182,12 @@ export 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.`);
+            }
         }
     }
     splitArray(arr, chunkSize) {
@@ -219,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);
@@ -238,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));
@@ -373,6 +355,37 @@ 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) {
@@ -432,7 +445,12 @@ export class TweakedTransaction extends Logger {
     }
     async signTaprootInput(signer, transaction, i, tapLeafHash) {
         if ('signTaprootInput' in signer) {
-            await signer.signTaprootInput(transaction, i, tapLeafHash);
+            try {
+                await signer.signTaprootInput(transaction, i, tapLeafHash);
+            }
+            catch {
+                throw new Error('Failed to sign Taproot input with provided signer.');
+            }
         }
         else {
             transaction.signTaprootInput(i, signer);

package/build/utils/BitcoinUtils.d.ts

@@ -1,6 +1,6 @@
 export declare class BitcoinUtils {
     static btcToSatoshi(btc: number): bigint;
     static rndBytes(): Buffer;
-    static getUnsafeRandomValues(length: number): Buffer;
+    static getSafeRandomValues(length: number): Buffer;
     static opnetHash(data: Buffer): string;
 }

package/build/utils/BitcoinUtils.js

@@ -4,11 +4,13 @@ export class BitcoinUtils {
         return BigInt(btc * 100000000);
     }
     static rndBytes() {
-        const buf = BitcoinUtils.getUnsafeRandomValues(64);
+        const buf = BitcoinUtils.getSafeRandomValues(64);
         return Buffer.from(buf);
     }
-    static getUnsafeRandomValues(length) {
-        if (typeof window !== 'undefined' && window.crypto && window.crypto.getRandomValues) {
+    static getSafeRandomValues(length) {
+        if (typeof globalThis.window !== 'undefined' &&
+            globalThis.window.crypto &&
+            typeof globalThis.window.crypto.getRandomValues === 'function') {
             const array = new Uint8Array(length);
             window.crypto.getRandomValues(array);
             return Buffer.from(array);
@@ -19,6 +21,7 @@ export class BitcoinUtils {
             return Buffer.from(array);
         }
         else {
+            console.log(`No secure random number generator available. Please upgrade your environment.`, globalThis.window.crypto, crypto);
             throw new Error('No secure random number generator available. Please upgrade your environment.');
         }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.1.2",
+    "version": "1.1.4",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

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

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

@@ -67,7 +67,7 @@ export interface Unisat {
 
     getNetwork(): Promise<UnisatNetwork>;
 
-    getChain(): Promise<UnisatChainType>;
+    getChain(): Promise<UnisatChainInfo>;
 
     getAccounts(): Promise<string[]>;
 
@@ -83,15 +83,23 @@ 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>;
 
     on(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
 
-    on(event: 'chainChanged' | 'networkChanged', listener: (network: UnisatNetwork) => void): void;
+    on(event: 'chainChanged', listener: (chain: UnisatChainInfo) => void): void;
+
+    on(event: 'networkChanged', listener: (network: UnisatChainInfo) => void): void;
+
+    on(event: 'disconnect', listener: () => void): void;
 
     removeListener(event: 'accountsChanged', listener: (accounts: string[]) => void): void;
 
-    removeListener(event: 'networkChanged', listener: (network: UnisatNetwork) => void): void;
+    removeListener(event: 'chainChanged', listener: (chain: UnisatChainInfo) => void): void;
+
+    removeListener(event: 'networkChanged', listener: (network: UnisatChainInfo) => void): void;
+
+    removeListener(event: 'disconnect', listener: () => void): void;
 }

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