@btc-vision/transaction 1.6.1 → 1.6.5

package/src/generators/builders/P2WDAGenerator.ts

@@ -0,0 +1,174 @@
+import { Network, networks } from '@btc-vision/bitcoin';
+import { BinaryWriter } from '../../buffer/BinaryWriter.js';
+import { Feature, Features } from '../Features.js';
+import { Generator } from '../Generator.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+
+export class P2WDAGenerator extends Generator {
+    private static readonly P2WDA_VERSION = 0x01;
+
+    constructor(
+        senderPubKey: Buffer,
+        contractSaltPubKey: Buffer,
+        network: Network = networks.bitcoin,
+    ) {
+        super(senderPubKey, contractSaltPubKey, network);
+    }
+
+    /**
+     * Validate that operation data will fit in P2WDA witness fields
+     *
+     * @param dataSize Size of the operation data
+     * @param maxWitnessFields Maximum number of witness fields (default 10)
+     * @param maxBytesPerWitness Maximum bytes per witness field (default 80)
+     * @returns true if data will fit, false otherwise
+     */
+    public static validateWitnessSize(
+        dataSize: number,
+        maxWitnessFields: number = 10,
+        maxBytesPerWitness: number = 80,
+    ): boolean {
+        // Account for Schnorr signature (64 bytes) and compression
+        // Assume 30% compression ratio (conservative estimate)
+
+        const signatureSize = 64;
+        const compressionRatio = 0.7;
+
+        const totalSize = dataSize + signatureSize;
+        const compressedSize = Math.ceil(totalSize * compressionRatio);
+
+        const requiredFields = Math.ceil(compressedSize / maxBytesPerWitness);
+
+        return requiredFields <= maxWitnessFields;
+    }
+
+    /**
+     * Compile operation data for P2WDA witness embedding
+     *
+     * This creates a binary structure containing all operation information
+     * without Bitcoin script opcodes. The structure is:
+     *
+     * [version(1)] [header(12)] [contract(32)] [challenge_pubkey(33)] [challenge_solution(32)]
+     * [calldata_length(4)] [calldata] [features_length(2)] [features_data]
+     *
+     * @param calldata The compressed calldata for the contract interaction
+     * @param contractSecret The 32-byte contract secret
+     * @param challenge The challenge solution for epoch rewards
+     * @param maxPriority Maximum priority fee in satoshis
+     * @param features Optional features like access lists
+     * @returns Raw operation data ready for signing and compression
+     */
+    public compile(
+        calldata: Buffer,
+        contractSecret: Buffer,
+        challenge: ChallengeSolution,
+        maxPriority: bigint,
+        features: Feature<Features>[] = [],
+    ): Buffer {
+        if (!this.contractSaltPubKey) {
+            throw new Error('Contract salt public key not set');
+        }
+
+        if (contractSecret.length !== 32) {
+            throw new Error('Contract secret must be exactly 32 bytes');
+        }
+
+        const writer = new BinaryWriter();
+
+        // Version byte
+        writer.writeU8(P2WDAGenerator.P2WDA_VERSION);
+
+        // Header
+        writer.writeBytes(
+            this.getHeader(
+                maxPriority,
+                features.map((f) => f.opcode),
+            ),
+        );
+
+        // Contract secret
+        writer.writeBytes(contractSecret);
+
+        // Challenge components for epoch rewards
+        writer.writeBytes(challenge.publicKey.originalPublicKeyBuffer());
+        writer.writeBytes(challenge.solution);
+
+        // Calldata with length prefix
+        writer.writeU32(calldata.length);
+        writer.writeBytes(calldata);
+
+        // Features
+        this.writeFeatures(writer, features);
+
+        return Buffer.from(writer.getBuffer());
+    }
+
+    /**
+     * Create a minimal header for P2WDA operations
+     *
+     * The header contains essential transaction metadata in a compact format:
+     * [sender_pubkey_prefix(1)] [feature_flags(3)] [max_priority(8)]
+     *
+     * @param maxPriority Maximum priority fee
+     * @param features Feature opcodes to set in flags
+     * @returns 12-byte header
+     */
+    public override getHeader(maxPriority: bigint, features: Features[] = []): Buffer {
+        return super.getHeader(maxPriority, features);
+    }
+
+    /**
+     * Write features section to the operation data
+     *
+     * Features are encoded as:
+     * [feature_count(2)] [feature1_opcode(1)] [feature1_length(4)] [feature1_data] ...
+     *
+     * @param writer Binary writer to write to
+     * @param features Array of features to encode
+     */
+    private writeFeatures(writer: BinaryWriter, features: Feature<Features>[]): void {
+        // Write feature count
+        writer.writeU16(features.length);
+
+        for (const feature of features) {
+            // Write feature opcode
+            writer.writeU8(feature.opcode);
+
+            // Encode feature data
+            const encodedData = this.encodeFeatureData(feature);
+
+            // Write feature data with length prefix
+            writer.writeU32(encodedData.length);
+            writer.writeBytes(encodedData);
+        }
+    }
+
+    /**
+     * Encode a single feature's data
+     *
+     * Unlike the base Generator class, we don't split into chunks here
+     * since P2WDA handles chunking at the witness level
+     *
+     * @param feature The feature to encode
+     * @returns Encoded feature data
+     */
+    private encodeFeatureData(feature: Feature<Features>): Buffer {
+        switch (feature.opcode) {
+            case Features.ACCESS_LIST: {
+                // Access lists are already encoded efficiently by the parent class
+                const chunks = this.encodeFeature(feature);
+                // Flatten chunks since P2WDA doesn't need script-level chunking
+                return Buffer.concat(chunks.flat());
+            }
+
+            case Features.EPOCH_SUBMISSION: {
+                // Epoch submissions are also handled by parent
+                const chunks = this.encodeFeature(feature);
+                return Buffer.concat(chunks.flat());
+            }
+
+            default:
+                throw new Error(`Unknown feature type: ${feature.opcode}`);
+        }
+    }
+}

package/src/keypair/Address.ts

@@ -5,7 +5,9 @@ import { AddressVerificator } from './AddressVerificator.js';
 import { EcKeyPair } from './EcKeyPair.js';
 import { ContractAddress } from '../transaction/ContractAddress.js';
 import { BitcoinUtils } from '../utils/BitcoinUtils.js';
-import { ITimeLockOutput, TimeLockGenerator } from '../transaction/mineable/TimelockGenerator.js';
+import { TimeLockGenerator } from '../transaction/mineable/TimelockGenerator.js';
+import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
+import { P2WDADetector } from '../p2wda/P2WDADetector.js';
 
 /**
  * Objects of type "Address" are the representation of tweaked public keys. They can be converted to different address formats.
@@ -19,6 +21,7 @@ export class Address extends Uint8Array {
     #keyPair: ECPairInterface | undefined;
     #uncompressed: UncompressedPublicKey | undefined;
     #tweakedUncompressed: Buffer | undefined;
+    #p2wda: IP2WSHAddress | undefined;
 
     public constructor(bytes?: ArrayLike<number>) {
         super(ADDRESS_BYTE_LENGTH);
@@ -318,6 +321,58 @@ export class Address extends Uint8Array {
         throw new Error('Public key not set');
     }
 
+    /**
+     * Generate a P2WDA (Pay-to-Witness-Data-Authentication) address
+     *
+     * P2WDA addresses are a special type of P2WSH address that allows embedding
+     * authenticated data directly in the witness field, achieving 75% cost reduction
+     * through Bitcoin's witness discount.
+     *
+     * The witness script pattern is: (OP_2DROP * 5) <pubkey> OP_CHECKSIG
+     * This allows up to 10 witness data fields (5 * 2 = 10), where each field
+     * can hold up to 80 bytes of data due to relay rules.
+     *
+     * @param {Network} network - The Bitcoin network to use
+     * @returns {IP2WSHAddress} The P2WDA address
+     * @throws {Error} If the public key is not set or address generation fails
+     *
+     * @example
+     * ```typescript
+     * const address = Address.fromString('0x02...');
+     * const p2wdaAddress = address.p2wda(networks.bitcoin);
+     * console.log(p2wdaAddress); // bc1q...
+     * ```
+     */
+    public p2wda(network: Network): IP2WSHAddress {
+        if (this.#p2wda && this.#network === network) {
+            return this.#p2wda;
+        }
+
+        if (!this.#originalPublicKey) {
+            throw new Error('Cannot create P2WDA address: public key not set');
+        }
+
+        const publicKeyBuffer = Buffer.from(this.#originalPublicKey);
+
+        if (publicKeyBuffer.length !== 33) {
+            throw new Error('P2WDA requires a compressed public key (33 bytes)');
+        }
+
+        try {
+            const p2wdaInfo = P2WDADetector.generateP2WDAAddress(publicKeyBuffer, network);
+
+            this.#network = network;
+            this.#p2wda = p2wdaInfo;
+
+            return {
+                address: p2wdaInfo.address,
+                witnessScript: p2wdaInfo.witnessScript,
+            };
+        } catch (error) {
+            throw new Error(`Failed to generate P2WDA address: ${(error as Error).message}`);
+        }
+    }
+
     /**
      * Generate a P2WSH address with CSV (CheckSequenceVerify) timelock
      * The resulting address can only be spent after the specified number of blocks
@@ -325,10 +380,10 @@ export class Address extends Uint8Array {
      *
      * @param {bigint | number | string} duration - The number of blocks that must pass before spending (1-65535)
      * @param {Network} network - The Bitcoin network to use
-     * @returns {ITimeLockOutput} The timelocked address and its witness script
+     * @returns {IP2WSHAddress} The timelocked address and its witness script
      * @throws {Error} If the block number is out of range or public key is not available
      */
-    public toCSV(duration: bigint | number | string, network: Network): ITimeLockOutput {
+    public toCSV(duration: bigint | number | string, network: Network): IP2WSHAddress {
         const n = Number(duration);
 
         // First, let's validate the block number to ensure it's within the valid range

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);
 
@@ -12,6 +13,16 @@ export enum AddressTypes {
     P2PK = 'P2PK',
     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 {
@@ -62,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.
@@ -193,11 +220,16 @@ export class AddressVerificator {
             }
 
             if (decodedBech32.prefix === network.bech32) {
-                // P2WPKH: SegWit address (starting with 'bc1q' for mainnet, 'tb1q' for testnet)
+                // P2WPKH: SegWit address (20 bytes)
                 if (decodedBech32.version === 0 && decodedBech32.data.length === 20) {
                     return AddressTypes.P2WPKH;
                 }
 
+                // P2WSH: SegWit script hash (32 bytes)
+                if (decodedBech32.version === 0 && decodedBech32.data.length === 32) {
+                    return AddressTypes.P2WSH;
+                }
+
                 // P2TR: Taproot address (starting with 'bc1p' for mainnet, 'tb1p' for testnet)
                 if (decodedBech32.version === 1 && decodedBech32.data.length === 32) {
                     return AddressTypes.P2TR;
@@ -207,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';