@btc-vision/transaction 1.6.1 → 1.6.5

package/build/keypair/AddressVerificator.d.ts

@@ -5,13 +5,25 @@ export declare enum AddressTypes {
     P2SH_OR_P2SH_P2WPKH = "P2SH_OR_P2SH-P2WPKH",
     P2PK = "P2PK",
     P2TR = "P2TR",
-    P2WPKH = "P2WPKH"
+    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 declare class AddressVerificator {
     static isValidP2TRAddress(inAddress: string, network: Network): boolean;
     static isP2WPKHAddress(inAddress: string, network: Network): boolean;
+    static isP2WDAWitnessScript(witnessScript: Buffer): boolean;
     static isP2PKHOrP2SH(addy: string, network: Network): boolean;
     static isValidPublicKey(input: string, network: Network): boolean;
     static requireRedeemScript(addy: string, network: Network): boolean;
     static detectAddressType(addy: string, network: Network): AddressTypes | null;
+    static detectAddressTypeWithWitnessScript(addy: string, network: Network, witnessScript?: Buffer): AddressTypes | null;
+    static validateP2WDAAddress(address: string, network: Network, witnessScript?: Buffer): ValidatedP2WDAAddress;
 }

package/build/keypair/AddressVerificator.js

@@ -1,7 +1,8 @@
-import { address, initEccLib } from '@btc-vision/bitcoin';
+import { address, initEccLib, 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);
 export var AddressTypes;
 (function (AddressTypes) {
@@ -11,6 +12,8 @@ export var AddressTypes;
     AddressTypes["P2PK"] = "P2PK";
     AddressTypes["P2TR"] = "P2TR";
     AddressTypes["P2WPKH"] = "P2WPKH";
+    AddressTypes["P2WSH"] = "P2WSH";
+    AddressTypes["P2WDA"] = "P2WDA";
 })(AddressTypes || (AddressTypes = {}));
 export class AddressVerificator {
     static isValidP2TRAddress(inAddress, network) {
@@ -38,6 +41,9 @@ export class AddressVerificator {
         catch { }
         return isValidSegWitAddress;
     }
+    static isP2WDAWitnessScript(witnessScript) {
+        return P2WDADetector.isP2WDAWitnessScript(witnessScript);
+    }
     static isP2PKHOrP2SH(addy, network) {
         try {
             const decodedBase58 = address.fromBase58Check(addy);
@@ -112,6 +118,9 @@ export class AddressVerificator {
                 if (decodedBech32.version === 0 && decodedBech32.data.length === 20) {
                     return AddressTypes.P2WPKH;
                 }
+                if (decodedBech32.version === 0 && decodedBech32.data.length === 32) {
+                    return AddressTypes.P2WSH;
+                }
                 if (decodedBech32.version === 1 && decodedBech32.data.length === 32) {
                     return AddressTypes.P2TR;
                 }
@@ -120,4 +129,76 @@ export class AddressVerificator {
         catch { }
         return null;
     }
+    static detectAddressTypeWithWitnessScript(addy, network, witnessScript) {
+        const baseType = AddressVerificator.detectAddressType(addy, network);
+        if (baseType === AddressTypes.P2WSH && witnessScript) {
+            if (AddressVerificator.isP2WDAWitnessScript(witnessScript)) {
+                return AddressTypes.P2WDA;
+            }
+        }
+        return baseType;
+    }
+    static validateP2WDAAddress(address, network, witnessScript) {
+        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.message,
+            };
+        }
+    }
 }

package/build/keypair/Wallet.d.ts

@@ -1,11 +1,13 @@
 import { ECPairInterface } from 'ecpair';
 import { Network } from '@btc-vision/bitcoin';
 import { Address } from './Address.js';
+import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 export declare class Wallet {
     readonly network: Network;
     private readonly _keypair;
     private readonly _p2wpkh;
     private readonly _p2tr;
+    private readonly _p2wda;
     private readonly _legacy;
     private readonly _segwitLegacy;
     private readonly _bufferPubKey;
@@ -17,6 +19,7 @@ export declare class Wallet {
     get keypair(): ECPairInterface;
     get p2wpkh(): string;
     get p2tr(): string;
+    get p2wda(): IP2WSHAddress;
     get legacy(): string;
     get addresses(): string[];
     get segwitLegacy(): string;

package/build/keypair/Wallet.js

@@ -20,6 +20,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();
     }
     get address() {
@@ -39,6 +40,9 @@ export class Wallet {
     get p2tr() {
         return this._p2tr;
     }
+    get p2wda() {
+        return this._p2wda;
+    }
     get legacy() {
         return this._legacy;
     }

package/build/opnet.d.ts

@@ -6,9 +6,12 @@ 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';
 export * from './generators/AddressGenerator.js';
 export * from './verification/TapscriptVerificator.js';
 export * from './keypair/AddressVerificator.js';
@@ -27,6 +30,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/build/opnet.js

@@ -5,9 +5,12 @@ 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';
 export * from './generators/AddressGenerator.js';
 export * from './verification/TapscriptVerificator.js';
 export * from './keypair/AddressVerificator.js';
@@ -26,6 +29,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/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;
+}