@btc-vision/transaction 1.6.11 → 1.6.13

package/src/opnet.ts

@@ -52,6 +52,7 @@ export * from './transaction/builders/InteractionTransactionP2WDA.js';
 export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
+export * from './transaction/builders/CancelTransaction.js';
 
 /** Epoch */
 export * from './epoch/interfaces/IChallengeSolution.js';

package/src/transaction/TransactionFactory.ts

@@ -36,7 +36,6 @@ export interface DeploymentResult {
     readonly contractPubKey: string;
     readonly challenge: RawChallenge;
 
-    readonly rawTransaction: Transaction;
     readonly utxos: UTXO[];
 }
 
@@ -58,8 +57,10 @@ export interface InteractionResponse {
     readonly interactionTransaction: string;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
+    readonly fundingUTXOs: UTXO[];
     readonly challenge: RawChallenge;
-    readonly rawTransaction: Transaction;
+    readonly interactionAddress: string | null;
+    readonly compiledTargetScript: string | null;
 }
 
 export interface BitcoinTransferResponse extends BitcoinTransferBase {
@@ -237,13 +238,14 @@ export class TransactionFactory {
             throw new Error('Could not sign funding transaction.');
         }
 
+        const fundingUTXO = this.getUTXOAsTransaction(
+            signedTransaction.tx,
+            finalTransaction.getScriptAddress(),
+            0,
+        );
         const newParams: IInteractionParameters = {
             ...interactionParameters,
-            utxos: this.getUTXOAsTransaction(
-                signedTransaction.tx,
-                finalTransaction.getScriptAddress(),
-                0,
-            ),
+            utxos: fundingUTXO,
             randomBytes: finalTransaction.getRndBytes(),
             challenge: challenge,
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
@@ -255,7 +257,7 @@ export class TransactionFactory {
         const outTx = await interactionTx.signTransaction();
 
         return {
-            rawTransaction: signedTransaction.tx,
+            interactionAddress: finalTransaction.getScriptAddress(),
             fundingTransaction: signedTransaction.tx.toHex(),
             interactionTransaction: outTx.toHex(),
             estimatedFees: interactionTx.transactionFee,
@@ -265,6 +267,8 @@ export class TransactionFactory {
                 1,
             ),
             challenge: challenge.toRaw(),
+            fundingUTXOs: fundingUTXO,
+            compiledTargetScript: interactionTx.exportCompiledTargetScript().toString('hex'),
         };
     }
 
@@ -369,7 +373,6 @@ export class TransactionFactory {
         };
 
         return {
-            rawTransaction: outTx,
             transaction: [signedTransaction.toHex(), outTx.toHex()],
             contractAddress: deploymentTx.getContractAddress(),
             contractPubKey: deploymentTx.contractPubKey,
@@ -587,7 +590,7 @@ export class TransactionFactory {
         const txHex = signedTx.toHex();
 
         return {
-            rawTransaction: signedTx,
+            interactionAddress: null,
             fundingTransaction: null,
             interactionTransaction: txHex,
             estimatedFees: p2wdaTransaction.estimatedFees,
@@ -596,7 +599,9 @@ export class TransactionFactory {
                 interactionParameters.from,
                 signedTx.outs.length - 1, // Last output is typically the change
             ),
+            fundingUTXOs: [...interactionParameters.utxos, ...inputs],
             challenge: interactionParameters.challenge.toRaw(),
+            compiledTargetScript: null,
         };
     }
 

package/src/transaction/builders/CancelTransaction.ts

@@ -0,0 +1,269 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { P2TRPayment, PaymentType, Psbt, PsbtInput, Taptree } from '@btc-vision/bitcoin';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { TapLeafScript } from '../interfaces/Tap.js';
+import {
+    ITransactionParameters,
+    SharedInteractionParameters,
+} from '../interfaces/ITransactionParameters.js';
+import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+
+export interface ICancelTransactionParameters
+    extends Omit<ITransactionParameters, 'priorityFee' | 'gasSatFee'> {
+    readonly compiledTargetScript: string | Buffer;
+}
+
+export class CancelTransaction extends TransactionBuilder<TransactionType.CANCEL> {
+    public type: TransactionType.CANCEL = TransactionType.CANCEL;
+
+    /**
+     * The tap leaf script for spending
+     */
+    protected tapLeafScript: TapLeafScript | null = null;
+
+    protected readonly compiledTargetScript: Buffer;
+    protected readonly scriptTree: Taptree;
+
+    protected readonly contractSecret: Buffer;
+    protected leftOverFundsScriptRedeem: P2TRPayment | null = null;
+
+    public constructor(parameters: ICancelTransactionParameters) {
+        super({
+            ...parameters,
+            gasSatFee: 1n,
+            isCancellation: true,
+            priorityFee: 1n,
+            calldata: Buffer.alloc(0),
+        } as unknown as SharedInteractionParameters);
+
+        this.contractSecret = Buffer.alloc(0);
+
+        if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+            this.compiledTargetScript = parameters.compiledTargetScript;
+        } else {
+            this.compiledTargetScript = Buffer.from(parameters.compiledTargetScript, 'hex');
+        }
+
+        // Generate the minimal script tree needed for recovery
+        this.scriptTree = this.getMinimalScriptTree();
+
+        this.internalInit();
+    }
+
+    protected override async buildTransaction(): Promise<void> {
+        if (!this.from) {
+            throw new Error('From address is required');
+        }
+
+        if (!this.leftOverFundsScriptRedeem) {
+            throw new Error('Left over funds script redeem is required');
+        }
+
+        if (!this.leftOverFundsScriptRedeem.redeemVersion) {
+            throw new Error('Left over funds script redeem version is required');
+        }
+
+        if (!this.leftOverFundsScriptRedeem.output) {
+            throw new Error('Left over funds script redeem output is required');
+        }
+
+        // Set up the tap leaf script for spending
+        this.tapLeafScript = {
+            leafVersion: this.leftOverFundsScriptRedeem.redeemVersion,
+            script: this.leftOverFundsScriptRedeem.output,
+            controlBlock: this.getWitness(),
+        };
+
+        this.addInputsFromUTXO();
+
+        await this.addRefundOutput(0n, true);
+
+        if (!this.feeOutput) {
+            throw new Error('Must add extra UTXOs to cancel this transaction');
+        }
+    }
+
+    /*protected override async buildTransaction(): Promise<void> {
+        if (!this.from) {
+            throw new Error('From address is required');
+        }
+
+        // For key-path spend, we don't need the tap leaf script
+        this.tapLeafScript = null;
+
+        this.addInputsFromUTXO();
+        await this.addRefundOutput(0n);
+    }*/
+
+    /**
+     * Sign the inputs
+     * @param {Psbt} transaction The transaction to sign
+     * @protected
+     */
+    /*protected async signInputs(transaction: Psbt): Promise<void> {
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (i === 0) {
+                transaction.signInput(0, this.getSignerKey());
+
+                transaction.finalizeInput(0, this.customFinalizer.bind(this));
+            } else {
+                await super.signInputs(transaction);
+            }
+        }
+    }*/
+
+    /**
+     * Generate the script address (for verification purposes)
+     */
+    protected override generateScriptAddress(): P2TRPayment {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: this.scriptTree,
+            name: PaymentType.P2TR,
+        };
+    }
+
+    /**
+     * Generate the tap data for spending
+     */
+    /*protected override generateTapData(): P2TRPayment {
+        const internalPubkey = this.internalPubKeyToXOnly();
+
+        return {
+            name: PaymentType.P2TR,
+            internalPubkey: internalPubkey,
+            network: this.network,
+            scriptTree: this.scriptTree, // This is crucial for the tweak
+        };
+    }*/
+    protected override generateTapData(): P2TRPayment {
+        const selectedRedeem = this.leftOverFundsScriptRedeem;
+
+        if (!selectedRedeem) {
+            throw new Error('Left over funds script redeem is required');
+        }
+
+        if (!this.scriptTree) {
+            throw new Error('Script tree is required');
+        }
+
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: this.scriptTree,
+            redeem: selectedRedeem,
+            name: PaymentType.P2TR,
+        };
+    }
+
+    /**
+     * Custom finalizer for the tap script spend
+     */
+    protected customFinalizer = (_inputIndex: number, input: PsbtInput) => {
+        if (!this.tapLeafScript) {
+            throw new Error('Tap leaf script is required');
+        }
+
+        if (!input.tapScriptSig || input.tapScriptSig.length === 0) {
+            throw new Error('Tap script signature is required');
+        }
+
+        // For the simple lock script, we only need the signature
+        const scriptSolution = [input.tapScriptSig[0].signature];
+
+        const witness = scriptSolution
+            .concat(this.tapLeafScript.script)
+            .concat(this.tapLeafScript.controlBlock);
+
+        return {
+            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witness),
+        };
+    };
+
+    protected override async signInputs(transaction: Psbt): Promise<void> {
+        if ('multiSignPsbt' in this.signer) {
+            await this.signInputsWalletBased(transaction);
+        } else {
+            await this.signInputsNonWalletBased(transaction);
+        }
+    }
+
+    protected override 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++) {
+            if (i === 0) {
+                transaction.finalizeInput(i, this.customFinalizer.bind(this));
+            } else {
+                try {
+                    transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
+                } 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.getSignerKey(),
+                );
+
+                transaction.finalizeInput(0, this.customFinalizer.bind(this));
+            } else {
+                await this.signInput(transaction, transaction.data.inputs[i], i, this.signer);
+
+                try {
+                    transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
+                } catch (e) {
+                    transaction.finalizeInput(i);
+                }
+            }
+        }
+    }
+
+    /**
+     * Generate the minimal script tree needed for recovery
+     * This only includes the leftover funds script
+     */
+    private getMinimalScriptTree(): Taptree {
+        this.generateLeftoverFundsRedeem();
+
+        if (!this.leftOverFundsScriptRedeem || !this.leftOverFundsScriptRedeem.output) {
+            throw new Error('Failed to generate leftover funds redeem script');
+        }
+
+        return [
+            {
+                output: this.compiledTargetScript,
+                version: 192,
+            },
+            {
+                output: this.leftOverFundsScriptRedeem.output,
+                version: 192,
+            },
+        ];
+    }
+
+    /**
+     * Generate the leftover funds redeem script
+     */
+    private generateLeftoverFundsRedeem(): void {
+        // Use the same LOCK_LEAF_SCRIPT from the parent class
+        this.leftOverFundsScriptRedeem = {
+            name: PaymentType.P2TR,
+            output: this.LOCK_LEAF_SCRIPT,
+            redeemVersion: 192,
+        };
+    }
+}

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -107,6 +107,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
 
         this.witnesses = parameters.witnesses;
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+        this.LOCK_LEAF_SCRIPT = this.defineLockScript();
 
         this.scriptSeed = this.getContractSeed();
         this.contractSigner = EcKeyPair.fromSeedKeyPair(this.scriptSeed, this.network);
@@ -353,7 +354,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * @private
      */
     private getLeafScript(): Buffer {
-        return TransactionBuilder.LOCK_LEAF_SCRIPT;
+        return this.LOCK_LEAF_SCRIPT;
     }
 
     /**

package/src/transaction/builders/DeploymentTransaction.ts

@@ -127,6 +127,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
         this.challenge = parameters.challenge;
 
+        this.LOCK_LEAF_SCRIPT = this.defineLockScript();
         this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(
             this.challenge.publicKey.originalPublicKeyBuffer(),
             this.network,
@@ -471,7 +472,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @private
      */
     private getLeafScript(): Buffer {
-        return TransactionBuilder.LOCK_LEAF_SCRIPT;
+        return this.LOCK_LEAF_SCRIPT;
     }
 
     /**

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -75,6 +75,8 @@ export abstract class SharedInteractionTransaction<
 
         this.challenge = parameters.challenge;
 
+        this.LOCK_LEAF_SCRIPT = this.defineLockScript();
+
         this.disableAutoRefund = parameters.disableAutoRefund || false;
         this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(
             this.challenge.publicKey.originalPublicKeyBuffer(),
@@ -93,6 +95,10 @@ export abstract class SharedInteractionTransaction<
         );
     }
 
+    public exportCompiledTargetScript(): Buffer {
+        return this.compiledTargetScript;
+    }
+
     /**
      * Get the contract secret
      * @returns {Buffer} The contract secret
@@ -262,7 +268,7 @@ export abstract class SharedInteractionTransaction<
                 version: 192,
             },
             {
-                output: SharedInteractionTransaction.LOCK_LEAF_SCRIPT,
+                output: this.LOCK_LEAF_SCRIPT,
                 version: 192,
             },
         ];
@@ -350,7 +356,8 @@ export abstract class SharedInteractionTransaction<
         this.addFeeToOutput(opnetFee, this.to, this.epochChallenge, false);
 
         // Get the actual amount added to outputs (might be MINIMUM_AMOUNT_REWARD if opnetFee is too small)
-        const actualOutputAmount = opnetFee < MINIMUM_AMOUNT_REWARD ? MINIMUM_AMOUNT_REWARD : opnetFee;
+        const actualOutputAmount =
+            opnetFee < MINIMUM_AMOUNT_REWARD ? MINIMUM_AMOUNT_REWARD : opnetFee;
 
         const optionalAmount = this.addOptionalOutputsAndGetAmount();
 
@@ -395,7 +402,7 @@ export abstract class SharedInteractionTransaction<
 
         this.leftOverFundsScriptRedeem = {
             name: PaymentType.P2TR,
-            output: SharedInteractionTransaction.LOCK_LEAF_SCRIPT,
+            output: this.LOCK_LEAF_SCRIPT,
             redeemVersion: 192,
         };
     }

package/src/transaction/builders/TransactionBuilder.ts

@@ -8,13 +8,17 @@ import bitcoin, {
     PsbtOutputExtended,
     script,
     Signer,
+    toXOnly,
     Transaction,
     varuint,
 } from '@btc-vision/bitcoin';
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { UpdateInput } from '../interfaces/Tap.js';
 import { TransactionType } from '../enums/TransactionType.js';
-import { IFundingTransactionParameters, ITransactionParameters, } from '../interfaces/ITransactionParameters.js';
+import {
+    IFundingTransactionParameters,
+    ITransactionParameters,
+} from '../interfaces/ITransactionParameters.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ECPairInterface } from 'ecpair';
@@ -37,18 +41,15 @@ export const ANCHOR_SCRIPT = Buffer.from('51024e73', 'hex');
  * @class TransactionBuilder
  */
 export abstract class TransactionBuilder<T extends TransactionType> extends TweakedTransaction {
-    // Cancel script
-    public static readonly LOCK_LEAF_SCRIPT: Buffer = script.compile([
-        opcodes.OP_FALSE,
-        opcodes.OP_VERIFY,
-    ]);
-
     public static readonly MINIMUM_DUST: bigint = 330n;
 
     public abstract readonly type: T;
     public readonly logColor: string = '#785def';
     public debugFees: boolean = false;
 
+    // Cancel script
+    public LOCK_LEAF_SCRIPT: Buffer;
+
     /**
      * @description The overflow fees of the transaction
      * @public
@@ -177,6 +178,8 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         this.to = parameters.to || undefined;
         this.debugFees = parameters.debugFees || false;
 
+        this.LOCK_LEAF_SCRIPT = this.defineLockScript();
+
         if (parameters.note) {
             if (typeof parameters.note === 'string') {
                 this.note = Buffer.from(parameters.note, 'utf8');
@@ -737,7 +740,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         return total;
     }
 
-    protected async addRefundOutput(amountSpent: bigint): Promise<void> {
+    protected async addRefundOutput(
+        amountSpent: bigint,
+        expectRefund: boolean = false,
+    ): Promise<void> {
         if (this.note) {
             this.addOPReturn(this.note);
         }
@@ -752,6 +758,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         let iterations = 0;
         const maxIterations = 5; // Prevent infinite loops
 
+        let sendBackAmount = 0n;
         // Iterate until fee stabilizes
         while (iterations < maxIterations && estimatedFee !== previousFee) {
             previousFee = estimatedFee;
@@ -763,7 +770,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             const totalSpent = amountSpent + estimatedFee;
 
             // Calculate refund
-            const sendBackAmount = this.totalInputAmount - totalSpent;
+            sendBackAmount = this.totalInputAmount - totalSpent;
 
             if (this.debugFees) {
                 this.log(
@@ -804,7 +811,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
                 this.feeOutput = null;
                 this.overflowFees = 0n;
 
-                if (sendBackAmount < 0n) {
+                if (sendBackAmount < 0n && iterations === maxIterations) {
                     throw new Error(
                         `Insufficient funds: need ${totalSpent} sats but only have ${this.totalInputAmount} sats`,
                     );
@@ -820,6 +827,12 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             iterations++;
         }
 
+        if (expectRefund && sendBackAmount < 0n) {
+            throw new Error(
+                `Insufficient funds: need at least ${-sendBackAmount} more sats to cover fees.`,
+            );
+        }
+
         if (iterations >= maxIterations) {
             this.warn(`Fee calculation did not stabilize after ${maxIterations} iterations`);
         }
@@ -834,6 +847,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         }
     }
 
+    protected defineLockScript(): Buffer {
+        return script.compile([toXOnly(Buffer.from(this.signer.publicKey)), opcodes.OP_CHECKSIG]);
+    }
+
     /**
      * @description Adds the value to the output
      * @param {number | bigint} value - The value to add

package/src/transaction/enums/TransactionType.ts

@@ -5,5 +5,5 @@ export enum TransactionType {
     INTERACTION = 3,
     MULTI_SIG = 4,
     CUSTOM_CODE = 5,
-    CHALLENGE_SOLUTION = 6,
+    CANCEL = 6,
 }

package/src/transaction/interfaces/ITransactionParameters.ts

@@ -46,6 +46,7 @@ export interface SharedInteractionParameters extends ITransactionParameters {
     readonly randomBytes?: Buffer;
 
     readonly loadedStorage?: LoadedStorage;
+    readonly isCancellation?: boolean;
 }
 
 export interface IInteractionParameters extends SharedInteractionParameters {

package/src/verification/TapscriptVerificator.ts

@@ -2,13 +2,14 @@ import {
     crypto as bitCrypto,
     Network,
     networks,
+    opcodes,
     Payment,
     payments,
+    script,
     Taptree,
     toXOnly,
 } from '@btc-vision/bitcoin';
 import { DeploymentGenerator } from '../generators/builders/DeploymentGenerator.js';
-import { TransactionBuilder } from '../transaction/builders/TransactionBuilder.js';
 import { ChallengeSolution } from '../epoch/ChallengeSolution.js';
 import { Feature, Features } from '../generators/Features.js';
 
@@ -46,13 +47,18 @@ export class TapscriptVerificator {
             params.features,
         );
 
+        const lockLeafScript = script.compile([
+            toXOnly(params.deployerPubKey),
+            opcodes.OP_CHECKSIG,
+        ]);
+
         const scriptTree: Taptree = [
             {
                 output: compiledTargetScript,
                 version: TapscriptVerificator.TAP_SCRIPT_VERSION,
             },
             {
-                output: TransactionBuilder.LOCK_LEAF_SCRIPT,
+                output: lockLeafScript,
                 version: TapscriptVerificator.TAP_SCRIPT_VERSION,
             },
         ];
@@ -80,13 +86,18 @@ export class TapscriptVerificator {
             params.features,
         );
 
+        const lockLeafScript = script.compile([
+            toXOnly(params.deployerPubKey),
+            opcodes.OP_CHECKSIG,
+        ]);
+
         const scriptTree: Taptree = [
             {
                 output: compiledTargetScript,
                 version: TapscriptVerificator.TAP_SCRIPT_VERSION,
             },
             {
-                output: TransactionBuilder.LOCK_LEAF_SCRIPT,
+                output: lockLeafScript,
                 version: TapscriptVerificator.TAP_SCRIPT_VERSION,
             },
         ];