@btc-vision/transaction 1.3.3 → 1.3.5

package/src/transaction/TransactionFactory.ts

@@ -19,7 +19,11 @@ import {
 } from './interfaces/ITransactionParameters.js';
 import { PSBTTypes } from './psbt/PSBTTypes.js';
 import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
-import { InteractionParametersWithoutSigner } from './browser/Web3Provider.js';
+import {
+    IDeploymentParametersWithoutSigner,
+    InteractionParametersWithoutSigner,
+} from './browser/Web3Provider.js';
+import { WindowWithWallets } from './browser/extensions/UnisatSigner.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
@@ -174,9 +178,11 @@ export class TransactionFactory {
             throw new Error('Field "signer" not provided, OP_WALLET not detected.');
         }
 
+        const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
         const preTransaction: InteractionTransaction = new InteractionTransaction({
             ...interactionParameters,
             utxos: [interactionParameters.utxos[0]], // we simulate one input here.
+            optionalInputs: inputs,
         });
 
         // we don't sign that transaction, we just need the parameters.
@@ -221,11 +227,14 @@ export class TransactionFactory {
 
         const newParams: IInteractionParameters = {
             ...interactionParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0), // always 0
+            utxos: [
+                ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
+            ], // always 0
             randomBytes: preTransaction.getRndBytes(),
             preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
+            optionalInputs: inputs,
         };
 
         const finalTransaction: InteractionTransaction = new InteractionTransaction(newParams);
@@ -253,21 +262,46 @@ export class TransactionFactory {
     public async signDeployment(
         deploymentParameters: IDeploymentParameters,
     ): Promise<DeploymentResult> {
-        const preTransaction: DeploymentTransaction = new DeploymentTransaction(
-            deploymentParameters,
-        );
+        const opWalletDeployment = await this.detectDeploymentOPWallet(deploymentParameters);
+        if (opWalletDeployment) {
+            return opWalletDeployment;
+        }
+
+        if (!('signer' in deploymentParameters)) {
+            throw new Error('Field "signer" not provided, OP_WALLET not detected.');
+        }
 
-        // Initial generation
-        await preTransaction.signTransaction();
+        const inputs = this.parseOptionalInputs(deploymentParameters.optionalInputs);
+        const preTransaction: DeploymentTransaction = new DeploymentTransaction({
+            ...deploymentParameters,
+            utxos: [deploymentParameters.utxos[0]], // we simulate one input here.
+            optionalInputs: inputs,
+        });
+
+        // we don't sign that transaction, we just need the parameters.
+        await preTransaction.generateTransactionMinimalSignatures();
 
         const parameters: IFundingTransactionParameters =
             await preTransaction.getFundingTransactionParameters();
 
+        parameters.utxos = deploymentParameters.utxos;
         parameters.amount =
             (await preTransaction.estimateTransactionFees()) +
             this.getPriorityFee(deploymentParameters) +
             preTransaction.getOptionalOutputValue();
 
+        const feeEstimationFundingTransaction = await this.createFundTransaction({
+            ...parameters,
+            optionalOutputs: [],
+            optionalInputs: [],
+        });
+
+        if (!feeEstimationFundingTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
+
         const fundingTransaction: FundingTransaction = new FundingTransaction({
             ...parameters,
             optionalInputs: [],
@@ -292,12 +326,12 @@ export class TransactionFactory {
 
         const newParams: IDeploymentParameters = {
             ...deploymentParameters,
-            utxos: [newUtxo],
+            utxos: [newUtxo], // always 0
             randomBytes: preTransaction.getRndBytes(),
             preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
-            optionalOutputs: [],
-            optionalInputs: [],
+            estimatedFees: preTransaction.estimatedFees,
+            optionalInputs: inputs,
         };
 
         const finalTransaction: DeploymentTransaction = new DeploymentTransaction(newParams);
@@ -396,14 +430,41 @@ export class TransactionFactory {
         return utxos;
     }
 
+    private parseOptionalInputs(optionalInputs?: UTXO[]): UTXO[] {
+        return (optionalInputs || []).map((input) => {
+            let nonWitness = input.nonWitnessUtxo;
+            if (
+                nonWitness &&
+                !(nonWitness instanceof Uint8Array) &&
+                typeof nonWitness === 'object'
+            ) {
+                nonWitness = Buffer.from(
+                    Uint8Array.from(
+                        Object.values(input.nonWitnessUtxo as unknown as Record<number, number>),
+                    ),
+                );
+            }
+
+            return {
+                ...input,
+                nonWitnessUtxo: nonWitness,
+            };
+        });
+    }
+
     private async detectInteractionOPWallet(
         interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner,
     ): Promise<InteractionResponse | null> {
-        if (typeof window === 'undefined' || !window.opnet || !window.opnet.web3) {
+        if (typeof window === 'undefined') {
             return null;
         }
 
-        const opnet = window.opnet.web3;
+        const _window = window as WindowWithWallets;
+        if (!_window || !_window.opnet || !_window.opnet.web3) {
+            return null;
+        }
+
+        const opnet = _window.opnet.web3;
         const interaction = await opnet.signInteraction({
             ...interactionParameters,
 
@@ -418,6 +479,33 @@ export class TransactionFactory {
         return interaction;
     }
 
+    private async detectDeploymentOPWallet(
+        deploymentParameters: IDeploymentParameters | IDeploymentParametersWithoutSigner,
+    ): Promise<DeploymentResult | null> {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+
+        const _window = window as WindowWithWallets;
+        if (!_window || !_window.opnet || !_window.opnet.web3) {
+            return null;
+        }
+
+        const opnet = _window.opnet.web3;
+        const deployment = await opnet.deployContract({
+            ...deploymentParameters,
+
+            // @ts-expect-error no, this is ok
+            signer: undefined,
+        });
+
+        if (!deployment) {
+            throw new Error('Could not sign interaction transaction.');
+        }
+
+        return deployment;
+    }
+
     private async _createChallengeSolution(
         parameters: IChallengeSolutionTransactionParameters,
     ): Promise<ChallengeSolutionResponse> {
@@ -426,6 +514,7 @@ export class TransactionFactory {
         const challengeTransaction: ChallengeSolutionTransaction = new ChallengeSolutionTransaction(
             parameters,
         );
+
         const signedTransaction: Transaction = await challengeTransaction.signTransaction();
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');

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

@@ -14,11 +14,9 @@ import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUt
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions, SignatureType, Unisat, UnisatNetwork } from '../types/Unisat.js';
 
-declare global {
-    interface Window {
-        unisat?: Unisat;
-        opnet?: Unisat;
-    }
+export interface WindowWithWallets {
+    unisat?: Unisat;
+    opnet?: Unisat;
 }
 
 export class UnisatSigner extends CustomKeypair {
@@ -83,7 +81,9 @@ export class UnisatSigner extends CustomKeypair {
     }
 
     public get unisat(): Unisat {
-        const module = window.unisat;
+        if (!window) throw new Error('Window not found');
+
+        const module = (window as WindowWithWallets).unisat;
         if (!module) {
             throw new Error('Unisat extension not found');
         }

package/src/transaction/builders/DeploymentTransaction.ts

@@ -118,7 +118,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             this.verifyCalldata();
         }
 
-        if(!parameters.preimage) throw new Error('Preimage is required');
+        if (!parameters.preimage) throw new Error('Preimage is required');
 
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
         this.preimage = parameters.preimage;
@@ -274,7 +274,11 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             if (i === 0) {
                 transaction.finalizeInput(i, this.customFinalizer);
             } else {
-                transaction.finalizeInput(i);
+                try {
+                    transaction.finalizeInput(i, this.customFinalizerP2SH);
+                } catch (e) {
+                    transaction.finalizeInput(i);
+                }
             }
         }
     }
@@ -305,7 +309,12 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
                 transaction.finalizeInput(0, this.customFinalizer);
             } else {
                 transaction.signInput(i, this.getSignerKey());
-                transaction.finalizeInput(i);
+
+                try {
+                    transaction.finalizeInput(i, this.customFinalizerP2SH);
+                } catch (e) {
+                    transaction.finalizeInput(i);
+                }
             }
         }
     }

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -67,7 +67,7 @@ export abstract class SharedInteractionTransaction<
             throw new Error('Calldata is required');
         }
 
-        if(!parameters.preimage) {
+        if (!parameters.preimage) {
             throw new Error('Preimage is required');
         }
 
@@ -319,7 +319,36 @@ export abstract class SharedInteractionTransaction<
             if (i === 0) {
                 transaction.finalizeInput(i, this.customFinalizer);
             } else {
-                transaction.finalizeInput(i);
+                try {
+                    transaction.finalizeInput(i, this.customFinalizerP2SH);
+                } catch (e) {
+                    transaction.finalizeInput(i);
+                }
+            }
+        }
+    }
+
+    protected override 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(0, this.customFinalizer);
+            } else {
+                await this.signInput(transaction, transaction.data.inputs[i], i, this.signer);
+
+                try {
+                    transaction.finalizeInput(i, this.customFinalizerP2SH);
+                } catch (e) {
+                    transaction.finalizeInput(i);
+                }
             }
         }
     }
@@ -359,32 +388,6 @@ export abstract class SharedInteractionTransaction<
         }
     }
 
-    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

@@ -626,9 +626,13 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         }
 
         if (this.optionalInputs) {
-            for (let i = 0; i < this.optionalInputs.length; i++) {
-                const utxo = this.optionalInputs[i];
-                const input = this.generatePsbtInputExtended(utxo, i);
+            for (
+                let i = this.utxos.length;
+                i < this.optionalInputs.length + this.utxos.length;
+                i++
+            ) {
+                const utxo = this.optionalInputs[i - this.utxos.length];
+                const input = this.generatePsbtInputExtended(utxo, i, true);
 
                 this.addInput(input);
             }

package/src/transaction/shared/TweakedTransaction.ts

@@ -462,6 +462,10 @@ export abstract class TweakedTransaction extends Logger {
             return;
         }
 
+        await this.signInputsNonWalletBased(transaction);
+    }
+
+    protected async signInputsNonWalletBased(transaction: Psbt): Promise<void> {
         // non web based signing.
         const txs: PsbtInput[] = transaction.data.inputs;
 
@@ -646,10 +650,15 @@ export abstract class TweakedTransaction extends Logger {
      * Generate the PSBT input extended, supporting various script types
      * @param {UTXO} utxo The UTXO
      * @param {number} i The index of the input
+     * @param {UTXO} extra Extra UTXO
      * @protected
      * @returns {PsbtInputExtended} The PSBT input extended
      */
-    protected generatePsbtInputExtended(utxo: UTXO, i: number): PsbtInputExtended {
+    protected generatePsbtInputExtended(
+        utxo: UTXO,
+        i: number,
+        extra: boolean = false,
+    ): PsbtInputExtended {
         const script = Buffer.from(utxo.scriptPubKey.hex, 'hex');
 
         const input: PsbtInputExtended = {
@@ -788,16 +797,29 @@ export abstract class TweakedTransaction extends Logger {
             this.error(`Unknown or unsupported script type for output: ${utxo.scriptPubKey.hex}`);
         }
 
-        // TapLeafScript if available
-        if (this.tapLeafScript) {
-            input.tapLeafScript = [this.tapLeafScript];
-        }
+        if (i === 0) {
+            // TapLeafScript if available
+            if (this.tapLeafScript) {
+                input.tapLeafScript = [this.tapLeafScript];
+            }
 
-        // If the first input and we have a global nonWitnessUtxo not yet set
-        if (i === 0 && this.nonWitnessUtxo) {
-            input.nonWitnessUtxo = this.nonWitnessUtxo;
+            if (this.nonWitnessUtxo) {
+                input.nonWitnessUtxo = this.nonWitnessUtxo;
+            }
         }
 
+        /*if (utxo.nonWitnessUtxo && extra) {
+            const witness = Buffer.isBuffer(utxo.nonWitnessUtxo)
+                ? utxo.nonWitnessUtxo
+                : typeof utxo.nonWitnessUtxo === 'string'
+                  ? Buffer.from(utxo.nonWitnessUtxo, 'hex')
+                  : (utxo.nonWitnessUtxo as unknown) instanceof Uint8Array
+                    ? Buffer.from(utxo.nonWitnessUtxo)
+                    : undefined;
+
+            input.nonWitnessUtxo = witness;
+        }*/
+
         return input;
     }
 
@@ -861,7 +883,16 @@ export abstract class TweakedTransaction extends Logger {
             }
 
             if (tweakedSigner) {
-                await this.signTaprootInput(tweakedSigner, transaction, i);
+                try {
+                    await this.signTaprootInput(tweakedSigner, transaction, i);
+                } catch (e) {
+                    tweakedSigner = this.getTweakedSigner(false, this.signer);
+                    if (!tweakedSigner) {
+                        throw new Error(`Failed to obtain tweaked signer for input ${i}.`);
+                    }
+
+                    await this.signTaprootInput(tweakedSigner, transaction, i);
+                }
             } else {
                 this.error(`Failed to obtain tweaked signer for input ${i}.`);
             }