@btc-vision/transaction 1.6.4 → 1.6.6

package/src/keypair/AddressVerificator.ts

@@ -1,7 +1,8 @@
-import { address, initEccLib, Network } from '@btc-vision/bitcoin';
+import { address, initEccLib, Network, payments } from '@btc-vision/bitcoin';
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { EcKeyPair } from './EcKeyPair.js';
 import { BitcoinUtils } from '../utils/BitcoinUtils.js';
+import { P2WDADetector } from '../p2wda/P2WDADetector.js';
 
 initEccLib(ecc);
 
@@ -13,6 +14,15 @@ export enum AddressTypes {
     P2TR = 'P2TR',
     P2WPKH = 'P2WPKH',
     P2WSH = 'P2WSH',
+    P2WDA = 'P2WDA',
+}
+
+export interface ValidatedP2WDAAddress {
+    readonly isValid: boolean;
+    readonly isPotentiallyP2WDA: boolean;
+    readonly isDefinitelyP2WDA: boolean;
+    readonly publicKey?: Buffer;
+    readonly error?: string;
 }
 
 export class AddressVerificator {
@@ -63,6 +73,22 @@ export class AddressVerificator {
         return isValidSegWitAddress;
     }
 
+    /**
+     * Check if a given witness script is a P2WDA witness script
+     *
+     * P2WDA witness scripts have a specific pattern:
+     * (OP_2DROP * 5) <pubkey> OP_CHECKSIG
+     *
+     * This pattern allows for 10 witness data fields (5 * 2 = 10),
+     * which can be used to embed authenticated operation data.
+     *
+     * @param witnessScript The witness script to check
+     * @returns true if this is a valid P2WDA witness script
+     */
+    public static isP2WDAWitnessScript(witnessScript: Buffer): boolean {
+        return P2WDADetector.isP2WDAWitnessScript(witnessScript);
+    }
+
     /**
      * Checks if the given address is a valid P2PKH or P2SH address.
      * @param addy - The address to check.
@@ -213,4 +239,117 @@ export class AddressVerificator {
 
         return null; // Not a valid or recognized Bitcoin address type
     }
+
+    /**
+     * Enhanced detectAddressType that provides hints about P2WDA
+     *
+     * Note: P2WDA addresses cannot be distinguished from regular P2WSH
+     * addresses without the witness script. When a P2WSH address is detected,
+     * it could potentially be P2WDA if it has the correct witness script.
+     *
+     * @param addy The address to analyze
+     * @param network The Bitcoin network
+     * @param witnessScript Optional witness script for P2WSH addresses
+     * @returns The address type, with P2WDA detection if witness script provided
+     */
+    public static detectAddressTypeWithWitnessScript(
+        addy: string,
+        network: Network,
+        witnessScript?: Buffer,
+    ): AddressTypes | null {
+        const baseType = AddressVerificator.detectAddressType(addy, network);
+
+        if (baseType === AddressTypes.P2WSH && witnessScript) {
+            if (AddressVerificator.isP2WDAWitnessScript(witnessScript)) {
+                return AddressTypes.P2WDA;
+            }
+        }
+
+        return baseType;
+    }
+
+    /**
+     * Validate a P2WDA address and extract information
+     *
+     * This method validates that an address is a properly formatted P2WSH
+     * address and, if a witness script is provided, verifies it matches
+     * the P2WDA pattern and corresponds to the address.
+     *
+     * @param address The address to validate
+     * @param network The Bitcoin network
+     * @param witnessScript Optional witness script to verify
+     * @returns Validation result with extracted information
+     */
+    public static validateP2WDAAddress(
+        address: string,
+        network: Network,
+        witnessScript?: Buffer,
+    ): ValidatedP2WDAAddress {
+        try {
+            const addressType = AddressVerificator.detectAddressType(address, network);
+            if (addressType !== AddressTypes.P2WSH) {
+                return {
+                    isValid: false,
+                    isPotentiallyP2WDA: false,
+                    isDefinitelyP2WDA: false,
+                    error: 'Not a P2WSH address',
+                };
+            }
+
+            if (!witnessScript) {
+                return {
+                    isValid: true,
+                    isPotentiallyP2WDA: true,
+                    isDefinitelyP2WDA: false,
+                };
+            }
+
+            if (!AddressVerificator.isP2WDAWitnessScript(witnessScript)) {
+                return {
+                    isValid: true,
+                    isPotentiallyP2WDA: true,
+                    isDefinitelyP2WDA: false,
+                    error: 'Witness script does not match P2WDA pattern',
+                };
+            }
+
+            const p2wsh = payments.p2wsh({
+                redeem: { output: witnessScript },
+                network,
+            });
+
+            if (p2wsh.address !== address) {
+                return {
+                    isValid: false,
+                    isPotentiallyP2WDA: false,
+                    isDefinitelyP2WDA: false,
+                    error: 'Witness script does not match address',
+                };
+            }
+
+            const publicKey = P2WDADetector.extractPublicKeyFromP2WDA(witnessScript);
+            if (!publicKey) {
+                return {
+                    isValid: false,
+                    isPotentiallyP2WDA: false,
+                    isDefinitelyP2WDA: false,
+                    error: 'Failed to extract public key from witness script',
+                };
+            }
+
+            return {
+                isValid: true,
+                isPotentiallyP2WDA: true,
+                isDefinitelyP2WDA: true,
+                publicKey,
+            };
+        } catch (error) {
+            return {
+                isValid: false,
+                isPotentiallyP2WDA: false,
+                isDefinitelyP2WDA: false,
+                error: (error as Error).message,
+            };
+        }
+    }
 }

package/src/keypair/Wallet.ts

@@ -3,6 +3,7 @@ import { EcKeyPair } from './EcKeyPair.js';
 import { Network, networks, toXOnly } from '@btc-vision/bitcoin';
 import { Address } from './Address.js';
 import { BitcoinUtils } from '../utils/BitcoinUtils.js';
+import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 
 /**
  * Wallet class
@@ -26,6 +27,12 @@ export class Wallet {
      */
     private readonly _p2tr: string;
 
+    /**
+     * P2WDA Pay-to-Witness-Data-Authentication
+     * @private
+     */
+    private readonly _p2wda: IP2WSHAddress;
+
     /**
      * Legacy address for the wallet
      * @private
@@ -80,6 +87,7 @@ export class Wallet {
         this._p2wpkh = this._address.p2wpkh(this.network);
         this._legacy = this._address.p2pkh(this.network);
         this._segwitLegacy = this._address.p2wpkh(this.network);
+        this._p2wda = this._address.p2wda(this.network);
 
         this._tweakedKey = this._address.toBuffer();
     }
@@ -126,6 +134,14 @@ export class Wallet {
         return this._p2tr;
     }
 
+    /**
+     * Get the P2WDA address for the wallet
+     * @returns {string}
+     */
+    public get p2wda(): IP2WSHAddress {
+        return this._p2wda;
+    }
+
     /**
      * Get the legacy address for the wallet
      * @returns {string}

package/src/opnet.ts

@@ -11,10 +11,13 @@ export * from './generators/builders/CustomGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
 export * from './generators/builders/LegacyCalldataGenerator.js';
 export * from './generators/builders/MultiSignGenerator.js';
+export * from './generators/builders/P2WDAGenerator.js';
 export * from './generators/Features.js';
 export * from './generators/Generator.js';
 
 export * from './transaction/mineable/TimelockGenerator.js';
+export * from './transaction/mineable/IP2WSHAddress.js';
+export * from './p2wda/P2WDADetector.js';
 
 /** Address */
 export * from './generators/AddressGenerator.js';
@@ -45,6 +48,7 @@ export * from './transaction/builders/CustomScriptTransaction.js';
 export * from './transaction/builders/DeploymentTransaction.js';
 export * from './transaction/builders/FundingTransaction.js';
 export * from './transaction/builders/InteractionTransaction.js';
+export * from './transaction/builders/InteractionTransactionP2WDA.js';
 export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';

package/src/p2wda/P2WDADetector.ts

@@ -0,0 +1,218 @@
+import { Buffer } from 'buffer';
+import { Network, opcodes, payments, script } from '@btc-vision/bitcoin';
+import { UTXO } from '../utxo/interfaces/IUTXO.js';
+import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
+
+/**
+ * P2WDA Detection and Validation Utilities
+ *
+ * This class provides methods to detect and validate P2WDA (Pay-to-Witness-Data-Authentication) addresses
+ * and UTXOs. P2WDA addresses have a specific witness script pattern that allows for efficient data storage.
+ */
+export class P2WDADetector {
+    /**
+     * Check if a UTXO is a P2WDA output by examining its script structure
+     *
+     * @param utxo The UTXO to check
+     * @returns true if this is a P2WDA UTXO
+     */
+    public static isP2WDAUTXO(utxo: UTXO): boolean {
+        // P2WDA outputs are P2WSH outputs with a specific witness script pattern
+        if (!utxo.witnessScript) {
+            return false;
+        }
+
+        const witnessScript = Buffer.isBuffer(utxo.witnessScript)
+            ? utxo.witnessScript
+            : Buffer.from(utxo.witnessScript, 'hex');
+
+        return this.isP2WDAWitnessScript(witnessScript);
+    }
+
+    /**
+     * Check if a witness script follows the P2WDA pattern
+     *
+     * P2WDA witness script pattern: (OP_2DROP * 5) <pubkey> OP_CHECKSIG
+     * This allows for up to 10 witness data fields (5 * 2 = 10)
+     *
+     * @param witnessScript The witness script to check
+     * @returns true if this is a P2WDA witness script
+     */
+    public static isP2WDAWitnessScript(witnessScript: Buffer): boolean {
+        try {
+            const decompiled = script.decompile(witnessScript);
+
+            if (!decompiled || decompiled.length !== 7) {
+                return false;
+            }
+
+            // Check for 5 OP_2DROP operations
+            for (let i = 0; i < 5; i++) {
+                if (decompiled[i] !== opcodes.OP_2DROP) {
+                    return false;
+                }
+            }
+
+            // Check for pubkey and OP_CHECKSIG
+            return (
+                Buffer.isBuffer(decompiled[5]) &&
+                decompiled[5].length === 33 && // Compressed public key
+                decompiled[6] === opcodes.OP_CHECKSIG
+            );
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Generate a P2WDA address from a public key
+     *
+     * @param publicKey The public key to use (33 bytes compressed)
+     * @param network The Bitcoin network
+     * @returns The P2WDA address and related payment information
+     */
+    public static generateP2WDAAddress(
+        publicKey: Buffer,
+        network: Network,
+    ): IP2WSHAddress & {
+        scriptPubKey: Buffer;
+    } {
+        if (publicKey.length !== 33) {
+            throw new Error('Public key must be 33 bytes (compressed)');
+        }
+
+        // Create the P2WDA witness script with 5x OP_2DROP
+        const witnessScript = script.compile([
+            opcodes.OP_2DROP,
+            opcodes.OP_2DROP,
+            opcodes.OP_2DROP,
+            opcodes.OP_2DROP,
+            opcodes.OP_2DROP,
+            publicKey,
+            opcodes.OP_CHECKSIG,
+        ]);
+
+        // Wrap in P2WSH
+        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,
+        };
+    }
+
+    /**
+     * Extract the public key from a P2WDA witness script
+     *
+     * @param witnessScript The P2WDA witness script
+     * @returns The public key or null if not a valid P2WDA script
+     */
+    public static extractPublicKeyFromP2WDA(witnessScript: Buffer): Buffer | null {
+        try {
+            const decompiled = script.decompile(witnessScript);
+
+            if (!decompiled || decompiled.length !== 7) {
+                return null;
+            }
+
+            // Check for 5x OP_2DROP pattern
+            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;
+        }
+    }
+
+    /**
+     * Create witness data for a simple P2WDA spend (no operation data)
+     *
+     * For simple transfers, P2WDA requires 10 dummy witness items (zeros) before the signature
+     *
+     * @param transactionSignature The transaction signature
+     * @param witnessScript The P2WDA witness script
+     * @returns The witness stack for a simple P2WDA spend
+     */
+    public static createSimpleP2WDAWitness(
+        transactionSignature: Buffer,
+        witnessScript: Buffer,
+    ): Buffer[] {
+        const witnessStack: Buffer[] = [transactionSignature];
+
+        // Add 10 empty buffers for the 5x OP_2DROP operations
+        // Bitcoin stack is reversed!
+        for (let i = 0; i < 10; i++) {
+            witnessStack.push(Buffer.alloc(0));
+        }
+
+        witnessStack.push(witnessScript);
+        return witnessStack;
+    }
+
+    /**
+     * Validate P2WDA operation data signature
+     *
+     * @param publicKey The public key from the witness script
+     * @param dataSignature The Schnorr signature
+     * @param operationData The operation data that was signed
+     * @returns true if the signature is valid
+     */
+    public static validateP2WDASignature(
+        publicKey: Buffer,
+        dataSignature: Buffer,
+        operationData: Buffer,
+    ): boolean {
+        // This would use MessageSigner.verifySignature internally
+        // For now, we'll assume the signature validation is handled by MessageSigner
+        return dataSignature.length === 64; // Schnorr signatures are always 64 bytes
+    }
+
+    /**
+     * Calculate the witness size for P2WDA transaction estimation
+     *
+     * @param dataSize The size of the operation data (0 for simple transfers)
+     * @returns The estimated witness size in bytes
+     */
+    public static estimateP2WDAWitnessSize(dataSize: number = 0): number {
+        // Witness structure:
+        // - Transaction signature: ~72 bytes
+        // - 10 data fields (can be empty or contain data)
+        // - Witness script: 39 bytes (5x OP_2DROP + 33-byte pubkey + OP_CHECKSIG)
+        // - Overhead for length prefixes: ~12 bytes (1 byte per witness element)
+
+        // For simple transfers, dataSize is 0 (10 empty fields)
+        // For interactions, dataSize is the total size of data split across fields
+        return 72 + dataSize + 39 + 12;
+    }
+
+    /**
+     * Check if a scriptPubKey is a P2WSH that could be P2WDA
+     *
+     * @param scriptPubKey The script public key to check
+     * @returns true if this could be a P2WDA output
+     */
+    public static couldBeP2WDA(scriptPubKey: Buffer): boolean {
+        // P2WDA uses P2WSH, which is version 0 witness with 32-byte program
+        return scriptPubKey.length === 34 && scriptPubKey[0] === 0x00 && scriptPubKey[1] === 0x20; // 32 bytes
+    }
+}

package/src/transaction/TransactionFactory.ts

@@ -23,6 +23,8 @@ import {
 } from './browser/Web3Provider.js';
 import { WindowWithWallets } from './browser/extensions/UnisatSigner.js';
 import { RawChallenge } from '../epoch/interfaces/IChallengeSolution.js';
+import { P2WDADetector } from '../p2wda/P2WDADetector.js';
+import { InteractionTransactionP2WDA } from './builders/InteractionTransactionP2WDA.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
@@ -48,7 +50,7 @@ export interface BitcoinTransferBase {
 }
 
 export interface InteractionResponse {
-    readonly fundingTransaction: string;
+    readonly fundingTransaction: string | null;
     readonly interactionTransaction: string;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
@@ -181,6 +183,11 @@ export class TransactionFactory {
             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: InteractionTransaction = new InteractionTransaction({
             ...interactionParameters,
@@ -234,7 +241,7 @@ export class TransactionFactory {
                 ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
             ], // always 0
             randomBytes: preTransaction.getRndBytes(),
-            challenge: preTransaction.getPreimage(),
+            challenge: preTransaction.getChallenge(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -253,7 +260,7 @@ export class TransactionFactory {
                 interactionParameters.from,
                 1,
             ), // always 1
-            challenge: preTransaction.getPreimage().toRaw(),
+            challenge: preTransaction.getChallenge().toRaw(),
         };
     }
 
@@ -331,7 +338,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo], // always 0
             randomBytes: preTransaction.getRndBytes(),
-            challenge: preTransaction.getPreimage(),
+            challenge: preTransaction.getChallenge(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -358,7 +365,7 @@ export class TransactionFactory {
             contractAddress: finalTransaction.getContractAddress(), //finalTransaction.contractAddress.p2tr(deploymentParameters.network),
             contractPubKey: finalTransaction.contractPubKey,
             utxos: [refundUTXO],
-            challenge: preTransaction.getPreimage().toRaw(),
+            challenge: preTransaction.getChallenge().toRaw(),
         };
     }
 
@@ -506,6 +513,20 @@ export class TransactionFactory {
         };
     }
 
+    /**
+     * Check if the UTXOs contain any P2WDA inputs
+     *
+     * This method examines both main UTXOs and optional inputs to determine
+     * if any of them are P2WDA addresses. P2WDA detection is based on the
+     * witness script pattern: (OP_2DROP * 5) <pubkey> OP_CHECKSIG
+     *
+     * @param utxos The main UTXOs to check
+     * @returns true if any UTXO is P2WDA, false otherwise
+     */
+    private hasP2WDAInputs(utxos: UTXO[]): boolean {
+        return utxos.some((utxo) => P2WDADetector.isP2WDAUTXO(utxo));
+    }
+
     private writePSBTHeader(type: PSBTTypes, psbt: string): string {
         const buf = Buffer.from(psbt, 'base64');
 
@@ -516,6 +537,59 @@ export class TransactionFactory {
         return Buffer.concat([header, buf]).toString('hex');
     }
 
+    /**
+     * Sign a P2WDA interaction transaction
+     *
+     * P2WDA interactions are fundamentally different from standard OP_NET interactions.
+     * Instead of using a two-transaction model (funding + interaction), P2WDA embeds
+     * the operation data directly in the witness field of a single transaction.
+     * This achieves significant cost savings through the witness discount.
+     *
+     * Key differences:
+     * - Single transaction instead of two
+     * - Operation data in witness field instead of taproot script
+     * - 75% cost reduction for data storage
+     * - No separate funding transaction needed
+     *
+     * @param interactionParameters The interaction parameters
+     * @returns The signed P2WDA interaction response
+     */
+    private async signP2WDAInteraction(
+        interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner,
+    ): Promise<InteractionResponse> {
+        if (!interactionParameters.from) {
+            throw new Error('Field "from" not provided.');
+        }
+
+        // Ensure we have a signer for P2WDA
+        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, // Last output is typically the change
+            ),
+            challenge: interactionParameters.challenge.toRaw(),
+        };
+    }
+
     private getPriorityFee(params: ITransactionParameters): bigint {
         const totalFee = params.priorityFee + params.gasSatFee;
         if (totalFee < TransactionBuilder.MINIMUM_DUST) {

package/src/transaction/builders/DeploymentTransaction.ts

@@ -27,9 +27,10 @@ import { SharedInteractionTransaction } from './SharedInteractionTransaction.js'
 import { ECPairInterface } from 'ecpair';
 import { Address } from '../../keypair/Address.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
-import { ITimeLockOutput, TimeLockGenerator } from '../mineable/TimelockGenerator.js';
+import { TimeLockGenerator } from '../mineable/TimelockGenerator.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 import { Feature, Features } from '../../generators/Features.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
@@ -37,7 +38,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
     public type: TransactionType.DEPLOYMENT = TransactionType.DEPLOYMENT;
 
     protected readonly challenge: ChallengeSolution;
-    protected readonly epochChallenge: ITimeLockOutput;
+    protected readonly epochChallenge: IP2WSHAddress;
 
     /**
      * The contract address
@@ -194,7 +195,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * Get the contract bytecode
      * @returns {Buffer} The contract bytecode
      */
-    public getPreimage(): ChallengeSolution {
+    public getChallenge(): ChallengeSolution {
         return this.challenge;
     }