@btc-vision/transaction 1.6.4 → 1.6.6

package/src/transaction/builders/InteractionTransactionP2WDA.ts

@@ -0,0 +1,380 @@
+import { Buffer } from 'buffer';
+import { Psbt, PsbtInput, toXOnly } from '@btc-vision/bitcoin';
+import { TransactionType } from '../enums/TransactionType.js';
+import { IInteractionParameters } from '../interfaces/ITransactionParameters.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 { Feature, Features } from '../../generators/Features.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
+import { ECPairInterface } from 'ecpair';
+import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import { TimeLockGenerator } from '../mineable/TimelockGenerator.js';
+
+/**
+ * P2WDA Interaction Transaction
+ *
+ * This transaction type uses the exact same operation data as regular interactions
+ * (via CalldataGenerator), but embeds it in the witness field instead of a taproot script.
+ * This achieves 75% cost reduction through the witness discount.
+ */
+export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionType.INTERACTION> {
+    private static readonly MAX_WITNESS_FIELDS = 10;
+    private static readonly MAX_BYTES_PER_WITNESS = 80;
+
+    public readonly type: TransactionType.INTERACTION = TransactionType.INTERACTION;
+    protected readonly epochChallenge: IP2WSHAddress;
+    /**
+     * Disable auto refund
+     * @protected
+     */
+    protected readonly disableAutoRefund: boolean;
+    private readonly contractAddress: string;
+    private readonly contractSecret: Buffer;
+    private readonly calldata: Buffer;
+    private readonly challenge: ChallengeSolution;
+    private readonly randomBytes: Buffer;
+    private p2wdaGenerator: P2WDAGenerator;
+    private scriptSigner: ECPairInterface;
+    private p2wdaInputIndices: Set<number> = new Set();
+    /**
+     * The compiled operation data from CalldataGenerator
+     * This is exactly what would go in a taproot script, but we put it in witness instead
+     */
+    private readonly compiledOperationData: Buffer | null = null;
+
+    public constructor(parameters: IInteractionParameters) {
+        super(parameters);
+
+        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();
+
+        // Create the script signer (same as SharedInteractionTransaction does)
+        this.scriptSigner = this.generateKeyPairFromSeed();
+
+        // Create the P2WDA generator instead of CalldataGenerator
+        // P2WDA needs a different data format optimized for witness embedding
+        this.p2wdaGenerator = new P2WDAGenerator(
+            Buffer.from(this.signer.publicKey),
+            this.scriptSignerXOnlyPubKey(),
+            this.network,
+        );
+
+        // Validate contract secret
+        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,
+        );
+
+        // Validate P2WDA inputs
+        this.validateP2WDAInputs();
+
+        this.compiledOperationData = this.p2wdaGenerator.compile(
+            this.calldata,
+            this.contractSecret,
+            this.challenge,
+            this.priorityFee,
+            this.generateFeatures(parameters),
+        );
+
+        // Validate size early
+        this.validateOperationDataSize();
+
+        this.internalInit();
+    }
+
+    /**
+     * Get random bytes (for compatibility if needed elsewhere)
+     */
+    public getRndBytes(): Buffer {
+        return this.randomBytes;
+    }
+
+    /**
+     * Get the challenge (for compatibility if needed elsewhere)
+     */
+    public getChallenge(): ChallengeSolution {
+        return this.challenge;
+    }
+
+    /**
+     * Get contract secret (for compatibility if needed elsewhere)
+     */
+    public getContractSecret(): Buffer {
+        return this.contractSecret;
+    }
+
+    /**
+     * Build the transaction
+     */
+    protected async buildTransaction(): Promise<void> {
+        if (!this.regenerated) {
+            this.addInputsFromUTXO();
+        }
+
+        // Add refund
+        await this.createMineableRewardOutputs();
+    }
+
+    protected async createMineableRewardOutputs(): Promise<void> {
+        if (!this.to) throw new Error('To address is required');
+
+        const amountSpent: bigint = this.getTransactionOPNetFee();
+
+        let amountToCA: bigint;
+        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+            amountToCA = MINIMUM_AMOUNT_CA;
+        } else {
+            amountToCA = amountSpent;
+        }
+
+        // ALWAYS THE FIRST INPUT.
+        this.addOutput({
+            value: Number(amountToCA),
+            address: this.to,
+        });
+
+        // ALWAYS SECOND.
+        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);
+        }
+    }
+
+    /**
+     * Sign inputs with P2WDA-specific handling
+     */
+    protected override async signInputs(transaction: Psbt): Promise<void> {
+        // Sign all inputs
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            await this.signInput(transaction, transaction.data.inputs[i], i, this.signer);
+        }
+
+        // Finalize with appropriate finalizers
+        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;
+    }
+
+    /**
+     * Generate features array (same as InteractionTransaction)
+     */
+    private generateFeatures(parameters: IInteractionParameters): Feature<Features>[] {
+        const features: Feature<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;
+    }
+
+    /**
+     * Generate keypair from seed (same as SharedInteractionTransaction)
+     */
+    private generateKeyPairFromSeed(): ECPairInterface {
+        return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
+    }
+
+    /**
+     * Get script signer x-only pubkey (same as SharedInteractionTransaction)
+     */
+    private scriptSignerXOnlyPubKey(): Buffer {
+        return toXOnly(Buffer.from(this.scriptSigner.publicKey));
+    }
+
+    /**
+     * Validate that input 0 is P2WDA
+     */
+    private validateP2WDAInputs(): void {
+        if (this.utxos.length === 0 || !P2WDADetector.isP2WDAUTXO(this.utxos[0])) {
+            throw new Error('Input 0 must be a P2WDA UTXO');
+        }
+
+        // Track all P2WDA inputs
+        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);
+            }
+        }
+    }
+
+    /**
+     * Validate the compiled operation data will fit in witness fields
+     */
+    private validateOperationDataSize(): void {
+        if (!this.compiledOperationData) {
+            throw new Error('Operation data not compiled');
+        }
+
+        // The data that goes in witness: COMPRESS(signature + compiledOperationData)
+        // Signature is 64 bytes
+        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}`,
+            );
+        }
+    }
+
+    /**
+     * Finalize primary P2WDA input with the operation data
+     * This is where we create the signature and compress everything
+     */
+    private finalizePrimaryP2WDA(
+        inputIndex: number,
+        input: PsbtInput,
+    ): {
+        finalScriptSig: Buffer | undefined;
+        finalScriptWitness: Buffer | undefined;
+    } {
+        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 as ECPairInterface,
+            messageToSign,
+        );
+
+        const schnorrSignature = Buffer.from(signedMessage.signature);
+
+        // Combine and compress: COMPRESS(signature + compiledOperationData)
+        const fullData = Buffer.concat([schnorrSignature, this.compiledOperationData]);
+        const compressedData = Compressor.compress(fullData);
+
+        // Split into chunks
+        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}`,
+            );
+        }
+
+        // Build witness stack
+        const witnessStack: Buffer[] = [txSignature];
+
+        // Add exactly 10 data fields
+        // Bitcoin stack is reversed!
+        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),
+        };
+    }
+
+    /**
+     * Split data into 80-byte chunks
+     */
+    private splitIntoWitnessChunks(data: Buffer): Buffer[] {
+        const chunks: Buffer[] = [];
+        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;
+    }
+}

package/src/transaction/builders/MultiSignTransaction.ts

@@ -613,9 +613,9 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
     }
 
     private getTotalOutputAmount(utxos: UTXO[]): bigint {
-        let total = BigInt(0);
+        let total: bigint = 0n;
         for (const utxo of utxos) {
-            total += BigInt(utxo.value);
+            total += utxo.value;
         }
 
         return total;

package/src/transaction/builders/SharedInteractionTransaction.ts

@@ -1,6 +1,6 @@
-import { P2TRPayment, PaymentType, Psbt, PsbtInput, Signer, Taptree, toXOnly } from '@btc-vision/bitcoin';
+import { P2TRPayment, PaymentType, Psbt, PsbtInput, Signer, Taptree, toXOnly, } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
-import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder } from './TransactionBuilder.js';
+import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder, } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
@@ -8,8 +8,9 @@ import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.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 { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 
 /**
  * Shared interaction transaction
@@ -33,7 +34,7 @@ export abstract class SharedInteractionTransaction<
     protected abstract readonly scriptTree: Taptree;
 
     protected readonly challenge: ChallengeSolution;
-    protected readonly epochChallenge: ITimeLockOutput;
+    protected readonly epochChallenge: IP2WSHAddress;
 
     protected calldataGenerator: CalldataGenerator;
 
@@ -111,7 +112,7 @@ export abstract class SharedInteractionTransaction<
     /**
      * Get the preimage
      */
-    public getPreimage(): ChallengeSolution {
+    public getChallenge(): ChallengeSolution {
         return this.challenge;
     }
 
@@ -340,7 +341,7 @@ export abstract class SharedInteractionTransaction<
         }
     }
 
-    private async createMineableRewardOutputs(): Promise<void> {
+    protected async createMineableRewardOutputs(): Promise<void> {
         if (!this.to) throw new Error('To address is required');
 
         const amountSpent: bigint = this.getTransactionOPNetFee();

package/src/transaction/mineable/IP2WSHAddress.ts

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

package/src/transaction/mineable/TimelockGenerator.ts

@@ -1,9 +1,5 @@
 import bitcoin, { Network, networks, opcodes, script } from '@btc-vision/bitcoin';
-
-export interface ITimeLockOutput {
-    address: string;
-    witnessScript: Buffer;
-}
+import { IP2WSHAddress } from './IP2WSHAddress.js';
 
 export class TimeLockGenerator {
     private static readonly CSV_BLOCKS = 75;
@@ -16,7 +12,7 @@ export class TimeLockGenerator {
         publicKey: Buffer,
         network: Network = networks.bitcoin,
         csvBlocks: number = TimeLockGenerator.CSV_BLOCKS,
-    ): ITimeLockOutput {
+    ): IP2WSHAddress {
         const witnessScript = script.compile([
             script.number.encode(csvBlocks),
             opcodes.OP_CHECKSEQUENCEVERIFY,

package/src/transaction/shared/TweakedTransaction.ts

@@ -39,6 +39,8 @@ import {
     pubkeyInScript,
 } from '../../signer/SignerUtils.js';
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
+import { Buffer } from 'buffer';
+import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
 
 export type SupportedTransactionVersion = 1 | 2 | 3;
 
@@ -954,6 +956,11 @@ export abstract class TweakedTransaction extends Logger {
                 throw new Error(`No signatures for P2WSH input #${inputIndex}`);
             }
 
+            const isP2WDA = P2WDADetector.isP2WDAWitnessScript(input.witnessScript);
+            if (isP2WDA) {
+                return this.finalizeSecondaryP2WDA(inputIndex, input);
+            }
+
             // Check if this is a CSV input
             const isCSVInput = this.csvInputIndices.has(inputIndex);
             if (isCSVInput) {
@@ -981,6 +988,35 @@ export abstract class TweakedTransaction extends Logger {
         );
     };
 
+    /**
+     * Finalize secondary P2WDA inputs with empty data
+     */
+    protected finalizeSecondaryP2WDA(
+        inputIndex: number,
+        input: PsbtInput,
+    ): {
+        finalScriptWitness: Buffer | undefined;
+        finalScriptSig: Buffer | undefined;
+    } {
+        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),
+        };
+    }
+
     protected async signInputsWalletBased(transaction: Psbt): Promise<void> {
         const signer: UnisatSigner = this.signer as UnisatSigner;