@btc-vision/transaction 1.6.4 → 1.6.5

package/build/p2wda/P2WDADetector.d.ts

@@ -0,0 +1,16 @@
+import { Buffer } from 'buffer';
+import { Network } from '@btc-vision/bitcoin';
+import { UTXO } from '../utxo/interfaces/IUTXO.js';
+import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
+export declare class P2WDADetector {
+    static isP2WDAUTXO(utxo: UTXO): boolean;
+    static isP2WDAWitnessScript(witnessScript: Buffer): boolean;
+    static generateP2WDAAddress(publicKey: Buffer, network: Network): IP2WSHAddress & {
+        scriptPubKey: Buffer;
+    };
+    static extractPublicKeyFromP2WDA(witnessScript: Buffer): Buffer | null;
+    static createSimpleP2WDAWitness(transactionSignature: Buffer, witnessScript: Buffer): Buffer[];
+    static validateP2WDASignature(publicKey: Buffer, dataSignature: Buffer, operationData: Buffer): boolean;
+    static estimateP2WDAWitnessSize(dataSize?: number): number;
+    static couldBeP2WDA(scriptPubKey: Buffer): boolean;
+}

package/build/p2wda/P2WDADetector.js

@@ -0,0 +1,97 @@
+import { Buffer } from 'buffer';
+import { opcodes, payments, script } from '@btc-vision/bitcoin';
+export class P2WDADetector {
+    static isP2WDAUTXO(utxo) {
+        if (!utxo.witnessScript) {
+            return false;
+        }
+        const witnessScript = Buffer.isBuffer(utxo.witnessScript)
+            ? utxo.witnessScript
+            : Buffer.from(utxo.witnessScript, 'hex');
+        return this.isP2WDAWitnessScript(witnessScript);
+    }
+    static isP2WDAWitnessScript(witnessScript) {
+        try {
+            const decompiled = script.decompile(witnessScript);
+            if (!decompiled || decompiled.length !== 7) {
+                return false;
+            }
+            for (let i = 0; i < 5; i++) {
+                if (decompiled[i] !== opcodes.OP_2DROP) {
+                    return false;
+                }
+            }
+            return (Buffer.isBuffer(decompiled[5]) &&
+                decompiled[5].length === 33 &&
+                decompiled[6] === opcodes.OP_CHECKSIG);
+        }
+        catch {
+            return false;
+        }
+    }
+    static generateP2WDAAddress(publicKey, network) {
+        if (publicKey.length !== 33) {
+            throw new Error('Public key must be 33 bytes (compressed)');
+        }
+        const witnessScript = script.compile([
+            opcodes.OP_2DROP,
+            opcodes.OP_2DROP,
+            opcodes.OP_2DROP,
+            opcodes.OP_2DROP,
+            opcodes.OP_2DROP,
+            publicKey,
+            opcodes.OP_CHECKSIG,
+        ]);
+        const p2wsh = payments.p2wsh({
+            redeem: { output: witnessScript },
+            network,
+        });
+        if (!p2wsh.address || !p2wsh.output) {
+            throw new Error('Failed to generate P2WDA address');
+        }
+        return {
+            address: p2wsh.address,
+            witnessScript,
+            scriptPubKey: p2wsh.output,
+        };
+    }
+    static extractPublicKeyFromP2WDA(witnessScript) {
+        try {
+            const decompiled = script.decompile(witnessScript);
+            if (!decompiled || decompiled.length !== 7) {
+                return null;
+            }
+            for (let i = 0; i < 5; i++) {
+                if (decompiled[i] !== opcodes.OP_2DROP) {
+                    return null;
+                }
+            }
+            if (Buffer.isBuffer(decompiled[5]) &&
+                decompiled[5].length === 33 &&
+                decompiled[6] === opcodes.OP_CHECKSIG) {
+                return decompiled[5];
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    static createSimpleP2WDAWitness(transactionSignature, witnessScript) {
+        const witnessStack = [transactionSignature];
+        for (let i = 0; i < 10; i++) {
+            witnessStack.push(Buffer.alloc(0));
+        }
+        witnessStack.push(witnessScript);
+        return witnessStack;
+    }
+    static validateP2WDASignature(publicKey, dataSignature, operationData) {
+        return dataSignature.length === 64;
+    }
+    static estimateP2WDAWitnessSize(dataSize = 0) {
+        return 72 + dataSize + 39 + 12;
+    }
+    static couldBeP2WDA(scriptPubKey) {
+        return scriptPubKey.length === 34 && scriptPubKey[0] === 0x00 && scriptPubKey[1] === 0x20;
+    }
+}

package/build/transaction/TransactionFactory.d.ts

@@ -26,7 +26,7 @@ export interface BitcoinTransferBase {
     readonly nextUTXOs: UTXO[];
 }
 export interface InteractionResponse {
-    readonly fundingTransaction: string;
+    readonly fundingTransaction: string | null;
     readonly interactionTransaction: string;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
@@ -45,7 +45,9 @@ export declare class TransactionFactory {
     private detectInteractionOPWallet;
     private detectDeploymentOPWallet;
     private createFundTransaction;
+    private hasP2WDAInputs;
     private writePSBTHeader;
+    private signP2WDAInteraction;
     private getPriorityFee;
     private getUTXOAsTransaction;
 }

package/build/transaction/TransactionFactory.js

@@ -4,6 +4,8 @@ import { DeploymentTransaction } from './builders/DeploymentTransaction.js';
 import { FundingTransaction } from './builders/FundingTransaction.js';
 import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
+import { P2WDADetector } from '../p2wda/P2WDADetector.js';
+import { InteractionTransactionP2WDA } from './builders/InteractionTransactionP2WDA.js';
 export class TransactionFactory {
     async createCustomScriptTransaction(interactionParameters) {
         if (!interactionParameters.to) {
@@ -84,6 +86,10 @@ export class TransactionFactory {
         if (!('signer' in interactionParameters)) {
             throw new Error('Field "signer" not provided, OP_WALLET not detected.');
         }
+        const useP2WDA = this.hasP2WDAInputs(interactionParameters.utxos);
+        if (useP2WDA) {
+            return this.signP2WDAInteraction(interactionParameters);
+        }
         const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
         const preTransaction = new InteractionTransaction({
             ...interactionParameters,
@@ -121,7 +127,7 @@ export class TransactionFactory {
                 ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
             ],
             randomBytes: preTransaction.getRndBytes(),
-            challenge: preTransaction.getPreimage(),
+            challenge: preTransaction.getChallenge(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -133,7 +139,7 @@ export class TransactionFactory {
             interactionTransaction: outTx.toHex(),
             estimatedFees: preTransaction.estimatedFees,
             nextUTXOs: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1),
-            challenge: preTransaction.getPreimage().toRaw(),
+            challenge: preTransaction.getChallenge().toRaw(),
         };
     }
     async signDeployment(deploymentParameters) {
@@ -189,7 +195,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo],
             randomBytes: preTransaction.getRndBytes(),
-            challenge: preTransaction.getPreimage(),
+            challenge: preTransaction.getChallenge(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -211,7 +217,7 @@ export class TransactionFactory {
             contractAddress: finalTransaction.getContractAddress(),
             contractPubKey: finalTransaction.contractPubKey,
             utxos: [refundUTXO],
-            challenge: preTransaction.getPreimage().toRaw(),
+            challenge: preTransaction.getChallenge().toRaw(),
         };
     }
     async createBTCTransfer(parameters) {
@@ -307,6 +313,9 @@ export class TransactionFactory {
             nextUTXOs: this.getUTXOAsTransaction(signedTransaction, parameters.to, 0),
         };
     }
+    hasP2WDAInputs(utxos) {
+        return utxos.some((utxo) => P2WDADetector.isP2WDAUTXO(utxo));
+    }
     writePSBTHeader(type, psbt) {
         const buf = Buffer.from(psbt, 'base64');
         const header = Buffer.alloc(2);
@@ -314,6 +323,28 @@ export class TransactionFactory {
         header.writeUInt8(currentConsensus, 1);
         return Buffer.concat([header, buf]).toString('hex');
     }
+    async signP2WDAInteraction(interactionParameters) {
+        if (!interactionParameters.from) {
+            throw new Error('Field "from" not provided.');
+        }
+        if (!('signer' in interactionParameters)) {
+            throw new Error('P2WDA interactions require a signer. OP_WALLET is not supported for P2WDA.');
+        }
+        const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
+        const p2wdaTransaction = new InteractionTransactionP2WDA({
+            ...interactionParameters,
+            optionalInputs: inputs,
+        });
+        const signedTx = await p2wdaTransaction.signTransaction();
+        const txHex = signedTx.toHex();
+        return {
+            fundingTransaction: null,
+            interactionTransaction: txHex,
+            estimatedFees: p2wdaTransaction.estimatedFees,
+            nextUTXOs: this.getUTXOAsTransaction(signedTx, interactionParameters.from, signedTx.outs.length - 1),
+            challenge: interactionParameters.challenge.toRaw(),
+        };
+    }
     getPriorityFee(params) {
         const totalFee = params.priorityFee + params.gasSatFee;
         if (totalFee < TransactionBuilder.MINIMUM_DUST) {

package/build/transaction/builders/DeploymentTransaction.d.ts

@@ -4,13 +4,13 @@ import { P2TRPayment, Psbt } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { Address } from '../../keypair/Address.js';
-import { ITimeLockOutput } from '../mineable/TimelockGenerator.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 export declare class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     static readonly MAXIMUM_CONTRACT_SIZE: number;
     type: TransactionType.DEPLOYMENT;
     protected readonly challenge: ChallengeSolution;
-    protected readonly epochChallenge: ITimeLockOutput;
+    protected readonly epochChallenge: IP2WSHAddress;
     protected readonly _contractAddress: Address;
     protected tapLeafScript: TapLeafScript | null;
     private readonly deploymentVersion;
@@ -31,7 +31,7 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     get contractAddress(): Address;
     get p2trAddress(): string;
     getRndBytes(): Buffer;
-    getPreimage(): ChallengeSolution;
+    getChallenge(): ChallengeSolution;
     getContractAddress(): string;
     protected contractSignerXOnlyPubKey(): Buffer;
     protected buildTransaction(): Promise<void>;

package/build/transaction/builders/DeploymentTransaction.js

@@ -68,7 +68,7 @@ export class DeploymentTransaction extends TransactionBuilder {
     getRndBytes() {
         return this.randomBytes;
     }
-    getPreimage() {
+    getChallenge() {
         return this.challenge;
     }
     getContractAddress() {

package/build/transaction/builders/InteractionTransactionP2WDA.d.ts

@@ -0,0 +1,37 @@
+import { Buffer } from 'buffer';
+import { Psbt } from '@btc-vision/bitcoin';
+import { TransactionType } from '../enums/TransactionType.js';
+import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+export declare class InteractionTransactionP2WDA extends TransactionBuilder<TransactionType.INTERACTION> {
+    private static readonly MAX_WITNESS_FIELDS;
+    private static readonly MAX_BYTES_PER_WITNESS;
+    readonly type: TransactionType.INTERACTION;
+    protected readonly epochChallenge: IP2WSHAddress;
+    protected readonly disableAutoRefund: boolean;
+    private readonly contractAddress;
+    private readonly contractSecret;
+    private readonly calldata;
+    private readonly challenge;
+    private readonly randomBytes;
+    private p2wdaGenerator;
+    private scriptSigner;
+    private p2wdaInputIndices;
+    private readonly compiledOperationData;
+    constructor(parameters: IInteractionParameters);
+    getRndBytes(): Buffer;
+    getChallenge(): ChallengeSolution;
+    getContractSecret(): Buffer;
+    protected buildTransaction(): Promise<void>;
+    protected createMineableRewardOutputs(): Promise<void>;
+    protected signInputs(transaction: Psbt): Promise<void>;
+    private generateFeatures;
+    private generateKeyPairFromSeed;
+    private scriptSignerXOnlyPubKey;
+    private validateP2WDAInputs;
+    private validateOperationDataSize;
+    private finalizePrimaryP2WDA;
+    private splitIntoWitnessChunks;
+}

package/build/transaction/builders/InteractionTransactionP2WDA.js

@@ -0,0 +1,205 @@
+import { Buffer } from 'buffer';
+import { toXOnly } from '@btc-vision/bitcoin';
+import { TransactionType } from '../enums/TransactionType.js';
+import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
+import { MessageSigner } from '../../keypair/MessageSigner.js';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { P2WDAGenerator } from '../../generators/builders/P2WDAGenerator.js';
+import { Features } from '../../generators/Features.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+import { TimeLockGenerator } from '../mineable/TimelockGenerator.js';
+export class InteractionTransactionP2WDA extends TransactionBuilder {
+    constructor(parameters) {
+        super(parameters);
+        this.type = TransactionType.INTERACTION;
+        this.p2wdaInputIndices = new Set();
+        this.compiledOperationData = null;
+        if (!parameters.to) {
+            throw new Error('Contract address (to) is required');
+        }
+        if (!parameters.contract) {
+            throw new Error('Contract secret is required');
+        }
+        if (!parameters.calldata) {
+            throw new Error('Calldata is required');
+        }
+        if (!parameters.challenge) {
+            throw new Error('Challenge solution is required');
+        }
+        this.disableAutoRefund = parameters.disableAutoRefund || false;
+        this.contractAddress = parameters.to;
+        this.contractSecret = Buffer.from(parameters.contract.replace('0x', ''), 'hex');
+        this.calldata = Compressor.compress(parameters.calldata);
+        this.challenge = parameters.challenge;
+        this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+        this.scriptSigner = this.generateKeyPairFromSeed();
+        this.p2wdaGenerator = new P2WDAGenerator(Buffer.from(this.signer.publicKey), this.scriptSignerXOnlyPubKey(), this.network);
+        if (this.contractSecret.length !== 32) {
+            throw new Error('Invalid contract secret length. Expected 32 bytes.');
+        }
+        this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(this.challenge.publicKey.originalPublicKeyBuffer(), this.network);
+        this.validateP2WDAInputs();
+        this.compiledOperationData = this.p2wdaGenerator.compile(this.calldata, this.contractSecret, this.challenge, this.priorityFee, this.generateFeatures(parameters));
+        this.validateOperationDataSize();
+        this.internalInit();
+    }
+    getRndBytes() {
+        return this.randomBytes;
+    }
+    getChallenge() {
+        return this.challenge;
+    }
+    getContractSecret() {
+        return this.contractSecret;
+    }
+    async buildTransaction() {
+        if (!this.regenerated) {
+            this.addInputsFromUTXO();
+        }
+        await this.createMineableRewardOutputs();
+    }
+    async createMineableRewardOutputs() {
+        if (!this.to)
+            throw new Error('To address is required');
+        const amountSpent = this.getTransactionOPNetFee();
+        let amountToCA;
+        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+            amountToCA = MINIMUM_AMOUNT_CA;
+        }
+        else {
+            amountToCA = amountSpent;
+        }
+        this.addOutput({
+            value: Number(amountToCA),
+            address: this.to,
+        });
+        if (amountToCA === MINIMUM_AMOUNT_CA &&
+            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
+            this.addOutput({
+                value: Number(amountSpent - amountToCA),
+                address: this.epochChallenge.address,
+            });
+        }
+        const amount = this.addOptionalOutputsAndGetAmount();
+        if (!this.disableAutoRefund) {
+            await this.addRefundOutput(amountSpent + amount);
+        }
+    }
+    async signInputs(transaction) {
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            await this.signInput(transaction, transaction.data.inputs[i], i, this.signer);
+        }
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (this.p2wdaInputIndices.has(i)) {
+                if (i === 0) {
+                    transaction.finalizeInput(i, this.finalizePrimaryP2WDA.bind(this));
+                }
+                else {
+                    transaction.finalizeInput(i, this.finalizeSecondaryP2WDA.bind(this));
+                }
+            }
+            else {
+                transaction.finalizeInput(i, this.customFinalizerP2SH.bind(this));
+            }
+        }
+        this.finalized = true;
+    }
+    generateFeatures(parameters) {
+        const features = [];
+        if (parameters.loadedStorage) {
+            features.push({
+                opcode: Features.ACCESS_LIST,
+                data: parameters.loadedStorage,
+            });
+        }
+        const submission = parameters.challenge.getSubmission();
+        if (submission) {
+            features.push({
+                opcode: Features.EPOCH_SUBMISSION,
+                data: submission,
+            });
+        }
+        return features;
+    }
+    generateKeyPairFromSeed() {
+        return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
+    }
+    scriptSignerXOnlyPubKey() {
+        return toXOnly(Buffer.from(this.scriptSigner.publicKey));
+    }
+    validateP2WDAInputs() {
+        if (this.utxos.length === 0 || !P2WDADetector.isP2WDAUTXO(this.utxos[0])) {
+            throw new Error('Input 0 must be a P2WDA UTXO');
+        }
+        for (let i = 0; i < this.utxos.length; i++) {
+            if (P2WDADetector.isP2WDAUTXO(this.utxos[i])) {
+                this.p2wdaInputIndices.add(i);
+            }
+        }
+        for (let i = 0; i < this.optionalInputs.length; i++) {
+            const actualIndex = this.utxos.length + i;
+            if (P2WDADetector.isP2WDAUTXO(this.optionalInputs[i])) {
+                this.p2wdaInputIndices.add(actualIndex);
+            }
+        }
+    }
+    validateOperationDataSize() {
+        if (!this.compiledOperationData) {
+            throw new Error('Operation data not compiled');
+        }
+        const estimatedSize = this.compiledOperationData.length;
+        if (!P2WDAGenerator.validateWitnessSize(estimatedSize)) {
+            const signatureSize = 64;
+            const totalSize = estimatedSize + signatureSize;
+            const compressedEstimate = Math.ceil(totalSize * 0.7);
+            const requiredFields = Math.ceil(compressedEstimate / InteractionTransactionP2WDA.MAX_BYTES_PER_WITNESS);
+            throw new Error(`Please dont use P2WDA for this operation. Data too large. Raw size: ${estimatedSize} bytes, ` +
+                `estimated compressed: ${compressedEstimate} bytes, ` +
+                `needs ${requiredFields} witness fields, max is ${InteractionTransactionP2WDA.MAX_WITNESS_FIELDS}`);
+        }
+    }
+    finalizePrimaryP2WDA(inputIndex, input) {
+        if (!input.partialSig || input.partialSig.length === 0) {
+            throw new Error(`No signature for P2WDA input #${inputIndex}`);
+        }
+        if (!input.witnessScript) {
+            throw new Error(`No witness script for P2WDA input #${inputIndex}`);
+        }
+        if (!this.compiledOperationData) {
+            throw new Error('Operation data not compiled');
+        }
+        const txSignature = input.partialSig[0].signature;
+        const messageToSign = Buffer.concat([txSignature, this.compiledOperationData]);
+        const signedMessage = MessageSigner.signMessage(this.signer, messageToSign);
+        const schnorrSignature = Buffer.from(signedMessage.signature);
+        const fullData = Buffer.concat([schnorrSignature, this.compiledOperationData]);
+        const compressedData = Compressor.compress(fullData);
+        const chunks = this.splitIntoWitnessChunks(compressedData);
+        if (chunks.length > InteractionTransactionP2WDA.MAX_WITNESS_FIELDS) {
+            throw new Error(`Compressed data needs ${chunks.length} witness fields, max is ${InteractionTransactionP2WDA.MAX_WITNESS_FIELDS}`);
+        }
+        const witnessStack = [txSignature];
+        for (let i = 0; i < InteractionTransactionP2WDA.MAX_WITNESS_FIELDS; i++) {
+            witnessStack.push(i < chunks.length ? chunks[i] : Buffer.alloc(0));
+        }
+        witnessStack.push(input.witnessScript);
+        return {
+            finalScriptSig: undefined,
+            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witnessStack),
+        };
+    }
+    splitIntoWitnessChunks(data) {
+        const chunks = [];
+        let offset = 0;
+        while (offset < data.length) {
+            const size = Math.min(InteractionTransactionP2WDA.MAX_BYTES_PER_WITNESS, data.length - offset);
+            chunks.push(data.subarray(offset, offset + size));
+            offset += size;
+        }
+        return chunks;
+    }
+}
+InteractionTransactionP2WDA.MAX_WITNESS_FIELDS = 10;
+InteractionTransactionP2WDA.MAX_BYTES_PER_WITNESS = 80;

package/build/transaction/builders/SharedInteractionTransaction.d.ts

@@ -4,8 +4,8 @@ import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
-import { ITimeLockOutput } from '../mineable/TimelockGenerator.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 export declare abstract class SharedInteractionTransaction<T extends TransactionType> extends TransactionBuilder<T> {
     static readonly MAXIMUM_CALLDATA_SIZE: number;
     readonly randomBytes: Buffer;
@@ -14,7 +14,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected abstract readonly compiledTargetScript: Buffer;
     protected abstract readonly scriptTree: Taptree;
     protected readonly challenge: ChallengeSolution;
-    protected readonly epochChallenge: ITimeLockOutput;
+    protected readonly epochChallenge: IP2WSHAddress;
     protected calldataGenerator: CalldataGenerator;
     protected readonly calldata: Buffer;
     protected abstract readonly contractSecret: Buffer;
@@ -23,7 +23,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected constructor(parameters: SharedInteractionParameters);
     getContractSecret(): Buffer;
     getRndBytes(): Buffer;
-    getPreimage(): ChallengeSolution;
+    getChallenge(): ChallengeSolution;
     protected scriptSignerXOnlyPubKey(): Buffer;
     protected generateKeyPairFromSeed(): ECPairInterface;
     protected buildTransaction(): Promise<void>;
@@ -37,7 +37,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     };
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     protected signInputsNonWalletBased(transaction: Psbt): Promise<void>;
-    private createMineableRewardOutputs;
+    protected createMineableRewardOutputs(): Promise<void>;
     private getPubKeys;
     private generateRedeemScripts;
 }

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -1,5 +1,5 @@
-import { PaymentType, toXOnly } from '@btc-vision/bitcoin';
-import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder } from './TransactionBuilder.js';
+import { PaymentType, toXOnly, } from '@btc-vision/bitcoin';
+import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
@@ -45,7 +45,7 @@ export class SharedInteractionTransaction extends TransactionBuilder {
     getRndBytes() {
         return this.randomBytes;
     }
-    getPreimage() {
+    getChallenge() {
         return this.challenge;
     }
     scriptSignerXOnlyPubKey() {

package/build/transaction/mineable/IP2WSHAddress.d.ts

@@ -0,0 +1,4 @@
+export interface IP2WSHAddress {
+    address: string;
+    witnessScript: Buffer;
+}

package/build/transaction/mineable/IP2WSHAddress.js

@@ -0,0 +1 @@
+export {};

package/build/transaction/mineable/TimelockGenerator.d.ts

@@ -1,9 +1,6 @@
 import { Network } from '@btc-vision/bitcoin';
-export interface ITimeLockOutput {
-    address: string;
-    witnessScript: Buffer;
-}
+import { IP2WSHAddress } from './IP2WSHAddress.js';
 export declare class TimeLockGenerator {
     private static readonly CSV_BLOCKS;
-    static generateTimeLockAddress(publicKey: Buffer, network?: Network, csvBlocks?: number): ITimeLockOutput;
+    static generateTimeLockAddress(publicKey: Buffer, network?: Network, csvBlocks?: number): IP2WSHAddress;
 }

package/build/transaction/shared/TweakedTransaction.d.ts

@@ -5,6 +5,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import { Buffer } from 'buffer';
 export type SupportedTransactionVersion = 1 | 2 | 3;
 export interface ITweakedTransactionData {
     readonly signer: Signer | ECPairInterface | UnisatSigner;
@@ -88,6 +89,10 @@ export declare abstract class TweakedTransaction extends Logger {
         finalScriptSig: Buffer | undefined;
         finalScriptWitness: Buffer | undefined;
     };
+    protected finalizeSecondaryP2WDA(inputIndex: number, input: PsbtInput): {
+        finalScriptWitness: Buffer | undefined;
+        finalScriptSig: Buffer | undefined;
+    };
     protected signInputsWalletBased(transaction: Psbt): Promise<void>;
     protected isCSVScript(decompiled: (number | Buffer)[]): boolean;
     protected setCSVSequence(csvBlocks: number, currentSequence: number): number;

package/build/transaction/shared/TweakedTransaction.js

@@ -3,6 +3,8 @@ import { address as bitAddress, crypto as bitCrypto, getFinalScripts, isP2A, isP
 import { TweakedSigner } from '../../signer/TweakedSigner.js';
 import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../signer/SignerUtils.js';
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
+import { Buffer } from 'buffer';
+import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
 export var TransactionSequence;
 (function (TransactionSequence) {
     TransactionSequence[TransactionSequence["REPLACE_BY_FEE"] = 4294967293] = "REPLACE_BY_FEE";
@@ -52,6 +54,10 @@ export class TweakedTransaction extends Logger {
                 if (!input.partialSig || input.partialSig.length === 0) {
                     throw new Error(`No signatures for P2WSH input #${inputIndex}`);
                 }
+                const isP2WDA = P2WDADetector.isP2WDAWitnessScript(input.witnessScript);
+                if (isP2WDA) {
+                    return this.finalizeSecondaryP2WDA(inputIndex, input);
+                }
                 const isCSVInput = this.csvInputIndices.has(inputIndex);
                 if (isCSVInput) {
                     const witnessStack = [input.partialSig[0].signature, input.witnessScript];
@@ -509,6 +515,19 @@ export class TweakedTransaction extends Logger {
     extractCSVValue(sequence) {
         return sequence & 0x0000ffff;
     }
+    finalizeSecondaryP2WDA(inputIndex, input) {
+        if (!input.partialSig || input.partialSig.length === 0) {
+            throw new Error(`No signature for P2WDA input #${inputIndex}`);
+        }
+        if (!input.witnessScript) {
+            throw new Error(`No witness script for P2WDA input #${inputIndex}`);
+        }
+        const witnessStack = P2WDADetector.createSimpleP2WDAWitness(input.partialSig[0].signature, input.witnessScript);
+        return {
+            finalScriptSig: undefined,
+            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witnessStack),
+        };
+    }
     async signInputsWalletBased(transaction) {
         const signer = this.signer;
         await signer.multiSignPsbt([transaction]);

package/doc/addresses/P2OP.md

@@ -0,0 +1 @@
+