@btc-vision/transaction 1.7.6 → 1.7.10

package/src/keypair/MessageSigner.ts

@@ -4,6 +4,8 @@ import { crypto, Network, toXOnly } from '@btc-vision/bitcoin';
 import { TweakedSigner } from '../signer/TweakedSigner.js';
 import { EcKeyPair } from './EcKeyPair.js';
 import { MLDSASecurityLevel, QuantumBIP32Interface } from '@btc-vision/bip32';
+import { isOPWallet, OPWallet } from '../transaction/browser/types/OPWallet.js';
+import { MLDSASignature } from '../transaction/browser/Web3Provider.js';
 
 export interface SignedMessage {
     readonly signature: Uint8Array;
@@ -17,27 +19,204 @@ export interface MLDSASignedMessage {
     readonly securityLevel: MLDSASecurityLevel;
 }
 
+interface WindowWithOPWallet {
+    opnet?: OPWallet;
+}
+
 class MessageSignerBase {
     public sha256(message: Buffer | Uint8Array): Buffer {
         return crypto.sha256(Buffer.from(message));
     }
 
+    /**
+     * Attempts to sign a message using OP_WALLET if available in browser environment.
+     * Returns null if not in browser or OP_WALLET is not available.
+     * @param {Uint8Array | Buffer | string} message - The message to sign.
+     * @returns {Promise<SignedMessage | null>} The Schnorr signature or null if OP_WALLET unavailable.
+     */
+    public async trySignSchnorrWithOPWallet(
+        message: Uint8Array | Buffer | string,
+    ): Promise<SignedMessage | null> {
+        const wallet = this.getOPWallet();
+        if (!wallet) {
+            return null;
+        }
+
+        const messageBuffer =
+            typeof message === 'string' ? Buffer.from(message, 'utf-8') : Buffer.from(message);
+
+        const hashedMessage = this.sha256(messageBuffer);
+        const messageHex = hashedMessage.toString('hex');
+
+        const signatureHex = await wallet.web3.signSchnorr(messageHex);
+        return {
+            signature: Buffer.from(signatureHex, 'hex'),
+            message: hashedMessage,
+        };
+    }
+
+    /**
+     * Attempts to sign a message using OP_WALLET ML-DSA if available.
+     * Returns null if not in browser or OP_WALLET is not available.
+     * @param {Uint8Array | Buffer | string} message - The message to sign.
+     * @returns {Promise<MLDSASignedMessage | null>} The ML-DSA signature or null if OP_WALLET unavailable.
+     */
+    public async trySignMLDSAWithOPWallet(
+        message: Uint8Array | Buffer | string,
+    ): Promise<MLDSASignedMessage | null> {
+        const wallet = this.getOPWallet();
+        if (!wallet) {
+            return null;
+        }
+
+        const messageBuffer =
+            typeof message === 'string' ? Buffer.from(message, 'utf-8') : Buffer.from(message);
+
+        const hashedMessage = this.sha256(messageBuffer);
+        const messageHex = hashedMessage.toString('hex');
+
+        const result: MLDSASignature = await wallet.web3.signMLDSAMessage(messageHex);
+        return {
+            signature: Buffer.from(result.signature, 'hex'),
+            message: hashedMessage,
+            publicKey: Buffer.from(result.publicKey, 'hex'),
+            securityLevel: result.securityLevel,
+        };
+    }
+
+    /**
+     * Signs a message using Schnorr, automatically using OP_WALLET if available and no keypair provided.
+     * @param {Uint8Array | Buffer | string} message - The message to sign.
+     * @param {ECPairInterface} [keypair] - Optional keypair for local signing.
+     * @returns {Promise<SignedMessage>} The Schnorr signature.
+     * @throws {Error} If no keypair provided and OP_WALLET is not available.
+     */
+    public async signMessageAuto(
+        message: Uint8Array | Buffer | string,
+        keypair?: ECPairInterface,
+    ): Promise<SignedMessage> {
+        if (!keypair) {
+            const walletResult = await this.trySignSchnorrWithOPWallet(message);
+            if (walletResult) {
+                return walletResult;
+            }
+            throw new Error('No keypair provided and OP_WALLET is not available.');
+        }
+
+        return this.signMessage(keypair, message);
+    }
+
+    /**
+     * Signs a message with tweaking, automatically using OP_WALLET if available.
+     * Note: OP_WALLET signSchnorr may already return a tweaked signature depending on wallet implementation.
+     * @param {Uint8Array | Buffer | string} message - The message to sign.
+     * @param {ECPairInterface} [keypair] - Optional keypair for local signing.
+     * @param {Network} [network] - Network required when signing with a local keypair.
+     * @returns {Promise<SignedMessage>} The Schnorr signature.
+     * @throws {Error} If no keypair provided and OP_WALLET is not available.
+     * @throws {Error} If keypair provided but network is missing.
+     */
+    public async tweakAndSignMessageAuto(
+        message: Uint8Array | Buffer | string,
+        keypair?: ECPairInterface,
+        network?: Network,
+    ): Promise<SignedMessage> {
+        if (!keypair) {
+            const walletResult = await this.trySignSchnorrWithOPWallet(message);
+            if (walletResult) {
+                return walletResult;
+            }
+            throw new Error('No keypair provided and OP_WALLET is not available.');
+        }
+
+        if (!network) {
+            throw new Error('Network is required when signing with a local keypair.');
+        }
+
+        return this.tweakAndSignMessage(keypair, message, network);
+    }
+
+    /**
+     * Signs an ML-DSA message, automatically using OP_WALLET if available.
+     * @param {Uint8Array | Buffer | string} message - The message to sign.
+     * @param {QuantumBIP32Interface} [mldsaKeypair] - Optional ML-DSA keypair for local signing.
+     * @returns {Promise<MLDSASignedMessage>} The ML-DSA signature with metadata.
+     * @throws {Error} If no keypair provided and OP_WALLET is not available.
+     */
+    public async signMLDSAMessageAuto(
+        message: Uint8Array | Buffer | string,
+        mldsaKeypair?: QuantumBIP32Interface,
+    ): Promise<MLDSASignedMessage> {
+        if (!mldsaKeypair) {
+            const walletResult = await this.trySignMLDSAWithOPWallet(message);
+            if (walletResult) {
+                return walletResult;
+            }
+            throw new Error('No ML-DSA keypair provided and OP_WALLET is not available.');
+        }
+
+        return this.signMLDSAMessage(mldsaKeypair, message);
+    }
+
+    /**
+     * Verifies an ML-DSA signature using OP_WALLET if available.
+     * Returns null if OP_WALLET is not available.
+     * @param {Uint8Array | Buffer | string} message - The message to verify.
+     * @param {MLDSASignedMessage} signature - The ML-DSA signature to verify.
+     * @returns {Promise<boolean | null>} True if valid, false if invalid, null if OP_WALLET unavailable.
+     */
+    public async verifyMLDSAWithOPWallet(
+        message: Uint8Array | Buffer | string,
+        signature: MLDSASignedMessage,
+    ): Promise<boolean | null> {
+        const wallet = this.getOPWallet();
+        if (!wallet) {
+            return null;
+        }
+
+        const messageBuffer =
+            typeof message === 'string' ? Buffer.from(message, 'utf-8') : Buffer.from(message);
+
+        const hashedMessage = this.sha256(messageBuffer);
+
+        const mldsaSignature: MLDSASignature = {
+            signature: Buffer.from(signature.signature).toString('hex'),
+            publicKey: Buffer.from(signature.publicKey).toString('hex'),
+            securityLevel: signature.securityLevel,
+            messageHash: hashedMessage.toString('hex'),
+        };
+
+        return wallet.web3.verifyMLDSASignature(hashedMessage.toString('hex'), mldsaSignature);
+    }
+
+    /**
+     * Gets the ML-DSA public key from OP_WALLET if available.
+     * Returns null if OP_WALLET is not available.
+     * @returns {Promise<Buffer | null>} The ML-DSA public key or null if OP_WALLET unavailable.
+     */
+    public async getMLDSAPublicKeyFromOPWallet(): Promise<Buffer | null> {
+        const wallet = this.getOPWallet();
+        if (!wallet) {
+            return null;
+        }
+
+        const publicKeyHex = await wallet.web3.getMLDSAPublicKey();
+        return Buffer.from(publicKeyHex, 'hex');
+    }
+
     /**
      * Tweak the keypair and sign a message.
      * @param {ECPairInterface} keypair - The keypair to sign the message with. Must contain a private key.
      * @param {Uint8Array | Buffer | string} message - The message to sign.
      * @param {Network} network - The network to sign the message for.
-     * @returns The Schnorr signature.
+     * @returns {SignedMessage} The Schnorr signature.
      */
     public tweakAndSignMessage(
         keypair: ECPairInterface,
         message: Uint8Array | Buffer | string,
         network: Network,
     ): SignedMessage {
-        const tweaked = TweakedSigner.tweakSigner(keypair, {
-            network,
-        });
-
+        const tweaked = TweakedSigner.tweakSigner(keypair, { network });
         return this.signMessage(tweaked, message);
     }
 
@@ -45,8 +224,8 @@ class MessageSignerBase {
      * Signs a message using the provided keypair.
      * @param {ECPairInterface} keypair - The keypair to sign the message with. Must contain a private key.
      * @param {Uint8Array | Buffer | string} message - The message to sign.
-     * @returns The Schnorr signature.
-     * @throws Error if the private key is missing or invalid.
+     * @returns {SignedMessage} The Schnorr signature.
+     * @throws {Error} If the private key is missing or invalid.
      */
     public signMessage(
         keypair: ECPairInterface,
@@ -72,8 +251,8 @@ class MessageSignerBase {
      * @param {Uint8Array | Buffer} publicKey - The public key as a Uint8Array or Buffer.
      * @param {Uint8Array | Buffer | string} message - The message to verify.
      * @param {Uint8Array | Buffer} signature - The signature to verify.
-     * @returns True if the signature is valid, false otherwise.
-     * @throws Error if the signature length is invalid.
+     * @returns {boolean} True if the signature is valid, false otherwise.
+     * @throws {Error} If the signature length is invalid.
      */
     public verifySignature(
         publicKey: Uint8Array | Buffer,
@@ -97,8 +276,8 @@ class MessageSignerBase {
      * @param {Uint8Array | Buffer} publicKey - The public key as a Uint8Array or Buffer.
      * @param {Uint8Array | Buffer | string} message - The message to verify.
      * @param {Uint8Array | Buffer} signature - The signature to verify.
-     * @returns True if the signature is valid, false otherwise.
-     * @throws Error if the signature length is invalid.
+     * @returns {boolean} True if the signature is valid, false otherwise.
+     * @throws {Error} If the signature length is invalid.
      */
     public tweakAndVerifySignature(
         publicKey: Uint8Array | Buffer,
@@ -106,7 +285,6 @@ class MessageSignerBase {
         signature: Uint8Array | Buffer,
     ): boolean {
         const tweakedPublicKey = EcKeyPair.tweakPublicKey(Buffer.from(publicKey));
-
         return this.verifySignature(tweakedPublicKey, message, signature);
     }
 
@@ -114,8 +292,8 @@ class MessageSignerBase {
      * Signs a message using ML-DSA signature scheme.
      * @param {QuantumBIP32Interface} mldsaKeypair - The ML-DSA keypair to sign with. Must contain a private key.
      * @param {Uint8Array | Buffer | string} message - The message to sign.
-     * @returns The ML-DSA signature with metadata.
-     * @throws Error if the private key is missing.
+     * @returns {MLDSASignedMessage} The ML-DSA signature with metadata.
+     * @throws {Error} If the private key is missing.
      */
     public signMLDSAMessage(
         mldsaKeypair: QuantumBIP32Interface,
@@ -145,7 +323,7 @@ class MessageSignerBase {
      * @param {QuantumBIP32Interface} mldsaKeypair - The ML-DSA keypair with the public key.
      * @param {Uint8Array | Buffer | string} message - The message to verify.
      * @param {Uint8Array | Buffer} signature - The ML-DSA signature to verify.
-     * @returns True if the signature is valid, false otherwise.
+     * @returns {boolean} True if the signature is valid, false otherwise.
      */
     public verifyMLDSASignature(
         mldsaKeypair: QuantumBIP32Interface,
@@ -159,6 +337,27 @@ class MessageSignerBase {
         const hashedMessage = this.sha256(message);
         return mldsaKeypair.verify(hashedMessage, signature);
     }
+
+    /**
+     * Checks if OP_WALLET is available in the current environment.
+     * @returns {boolean} True if OP_WALLET is available, false otherwise.
+     */
+    public isOPWalletAvailable(): boolean {
+        return this.getOPWallet() !== null;
+    }
+
+    private getOPWallet(): OPWallet | null {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+
+        const _window = window as WindowWithOPWallet;
+        if (!_window.opnet || !isOPWallet(_window.opnet)) {
+            return null;
+        }
+
+        return _window.opnet;
+    }
 }
 
 export const MessageSigner = new MessageSignerBase();

package/src/opnet.ts

@@ -46,6 +46,8 @@ export {
     QuantumDerivationPath,
 } from '@btc-vision/bip32';
 
+export * from './generators/MLDSAData.js';
+
 /** Metadata */
 export * from './metadata/ContractBaseMetadata.js';
 export * from './network/ChainId.js';
@@ -125,7 +127,7 @@ export * from './transaction/browser/Web3Provider.js';
 export * from './keypair/Secp256k1PointDeriver.js';
 export * from './transaction/ContractAddress.js';
 
-export * from './deterministic/Map.js';
+export * from './deterministic/FastMap.js';
 export * from './deterministic/CustomMap.js';
 
 declare global {

package/src/transaction/TransactionFactory.ts

@@ -188,6 +188,7 @@ export class TransactionFactory {
             randomBytes: finalTransaction.getRndBytes(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: finalTransaction.estimatedFees,
+            compiledTargetScript: finalTransaction.exportCompiledTargetScript(),
             optionalInputs: inputs,
         };
 
@@ -288,6 +289,7 @@ export class TransactionFactory {
             utxos: fundingUTXO,
             randomBytes: finalTransaction.getRndBytes(),
             challenge: challenge,
+            compiledTargetScript: finalTransaction.exportCompiledTargetScript(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: finalTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -392,6 +394,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo],
             randomBytes: finalTransaction.getRndBytes(),
+            compiledTargetScript: finalTransaction.exportCompiledTargetScript(),
             challenge: challenge,
             nonWitnessUtxo: signedTransaction.toBuffer(),
             estimatedFees: finalTransaction.estimatedFees,

package/src/transaction/browser/Web3Provider.ts

@@ -6,25 +6,26 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { CancelledTransaction, DeploymentResult, InteractionResponse } from '../TransactionFactory';
 import { ICustomTransactionParameters } from '../builders/CustomScriptTransaction.js';
 import { ICancelTransactionParameters } from '../builders/CancelTransaction.js';
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
 
 export type InteractionParametersWithoutSigner = Omit<
     IInteractionParameters,
-    'signer' | 'challenge'
+    'signer' | 'challenge' | 'mldsaSigner'
 >;
 
 export type IDeploymentParametersWithoutSigner = Omit<
     IDeploymentParameters,
-    'signer' | 'network' | 'challenge'
+    'signer' | 'network' | 'challenge' | 'mldsaSigner'
 >;
 
 export type ICustomTransactionWithoutSigner = Omit<
     ICustomTransactionParameters,
-    'signer' | 'challenge'
+    'signer' | 'challenge' | 'mldsaSigner'
 >;
 
 export type ICancelTransactionParametersWithoutSigner = Omit<
     ICancelTransactionParameters,
-    'signer' | 'challenge' | 'network'
+    'signer' | 'challenge' | 'network' | 'mldsaSigner'
 >;
 
 export interface BroadcastTransactionOptions {
@@ -52,6 +53,31 @@ export interface BroadcastedTransaction {
     readonly peers?: number;
 }
 
+/**
+ * ML-DSA signature result
+ */
+export interface MLDSASignature {
+    /**
+     * The ML-DSA signature in hex format
+     */
+    readonly signature: string;
+
+    /**
+     * The ML-DSA public key used for signing in hex format
+     */
+    readonly publicKey: string;
+
+    /**
+     * The security level used (44, 65, or 87)
+     */
+    readonly securityLevel: MLDSASecurityLevel;
+
+    /**
+     * The message hash that was signed
+     */
+    readonly messageHash: string;
+}
+
 export interface Web3Provider {
     signInteraction(
         interactionParameters: InteractionParametersWithoutSigner,
@@ -70,4 +96,38 @@ export interface Web3Provider {
     deployContract(params: IDeploymentParametersWithoutSigner): Promise<DeploymentResult>;
 
     broadcast(transactions: BroadcastTransactionOptions[]): Promise<BroadcastedTransaction[]>;
+
+    /**
+     * Sign a message using Schnorr signature
+     * @param message - Hexadecimal string message to sign
+     * @returns The Schnorr signature in hex format
+     * @throws {Error} If signing fails or wallet is not connected
+     */
+    signSchnorr(message: string): Promise<string>;
+
+    /**
+     * Get the ML-DSA public key for the current account
+     *
+     * @returns The ML-DSA public key in hex format (never exposes private keys)
+     * @throws {Error} If the wallet is not connected
+     */
+    getMLDSAPublicKey(): Promise<string>;
+
+    /**
+     * Sign a message using ML-DSA signature
+     *
+     * @param message - The message to sign as a hexadecimal string
+     * @returns The ML-DSA signature
+     * @throws {Error} If signing fails or wallet is not connected
+     */
+    signMLDSAMessage(message: string): Promise<MLDSASignature>;
+
+    /**
+     * Verify an ML-DSA signature
+     *
+     * @param message - The original message, hexadecimal string
+     * @param signature - The ML-DSA signature to verify
+     * @returns True if the signature is valid
+     */
+    verifyMLDSASignature(message: string, signature: MLDSASignature): Promise<boolean>;
 }

package/src/transaction/browser/types/OPWallet.ts

@@ -1,30 +1,5 @@
 import { Unisat } from './Unisat.js';
-import { MLDSASecurityLevel } from '@btc-vision/bip32';
-
-/**
- * ML-DSA signature result
- */
-export interface MLDSASignature {
-    /**
-     * The ML-DSA signature in hex format
-     */
-    readonly signature: string;
-
-    /**
-     * The ML-DSA public key used for signing in hex format
-     */
-    readonly publicKey: string;
-
-    /**
-     * The security level used (44, 65, or 87)
-     */
-    readonly securityLevel: MLDSASecurityLevel;
-
-    /**
-     * The message hash that was signed
-     */
-    readonly messageHash: string;
-}
+import { Web3Provider } from '../Web3Provider.js';
 
 /**
  * OPWallet interface extending Unisat with ML-DSA (FIPS 204) support
@@ -33,31 +8,7 @@ export interface MLDSASignature {
  * Private keys are NEVER exposed through this interface.
  */
 export interface OPWallet extends Unisat {
-    /**
-     * Get the ML-DSA public key for the current account
-     *
-     * @returns The ML-DSA public key in hex format (never exposes private keys)
-     * @throws {Error} If the wallet is not connected
-     */
-    getMLDSAPublicKey(): Promise<string>;
-
-    /**
-     * Sign a message using ML-DSA signature
-     *
-     * @param message - The message to sign
-     * @returns The ML-DSA signature
-     * @throws {Error} If signing fails or wallet is not connected
-     */
-    signMLDSAMessage(message: string): Promise<MLDSASignature>;
-
-    /**
-     * Verify an ML-DSA signature
-     *
-     * @param message - The original message
-     * @param signature - The ML-DSA signature to verify
-     * @returns True if the signature is valid
-     */
-    verifyMLDSASignature(message: string, signature: MLDSASignature): Promise<boolean>;
+    web3: Web3Provider;
 }
 
 /**
@@ -67,7 +18,9 @@ export function isOPWallet(wallet: unknown): wallet is OPWallet {
     return (
         typeof wallet === 'object' &&
         wallet !== null &&
-        'getMLDSAPublicKey' in wallet &&
-        'signMLDSAMessage' in wallet
+        'web3' in wallet &&
+        typeof wallet.web3 === 'object' &&
+        'getMLDSAPublicKey' in (wallet.web3 as Web3Provider) &&
+        'signMLDSAMessage' in (wallet.web3 as Web3Provider)
     );
 }

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -137,6 +137,10 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
         return this.to || this.getScriptAddress();
     }
 
+    public exportCompiledTargetScript(): Buffer {
+        return this.compiledTargetScript;
+    }
+
     /**
      * Get the random bytes used for the interaction
      * @returns {Buffer} The random bytes

package/src/transaction/builders/DeploymentTransaction.ts

@@ -113,6 +113,10 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
     public constructor(parameters: IDeploymentParameters) {
         super(parameters);
 
+        if (!this.hashedPublicKey) {
+            throw new Error('MLDSA signer must be defined to deploy a contract.');
+        }
+
         this.bytecode = Compressor.compress(Buffer.concat([versionBuffer, parameters.bytecode]));
 
         this.verifyBytecode();
@@ -142,14 +146,24 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             this.network,
         );
 
-        this.compiledTargetScript = this.deploymentGenerator.compile(
-            this.bytecode,
-            this.randomBytes,
-            this.challenge,
-            this.priorityFee,
-            this.calldata,
-            this.generateFeatures(parameters),
-        );
+        if (parameters.compiledTargetScript) {
+            if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+                this.compiledTargetScript = parameters.compiledTargetScript;
+            } else if (typeof parameters.compiledTargetScript === 'string') {
+                this.compiledTargetScript = Buffer.from(parameters.compiledTargetScript, 'hex');
+            } else {
+                throw new Error('Invalid compiled target script format.');
+            }
+        } else {
+            this.compiledTargetScript = this.deploymentGenerator.compile(
+                this.bytecode,
+                this.randomBytes,
+                this.challenge,
+                this.priorityFee,
+                this.calldata,
+                this.generateFeatures(parameters),
+            );
+        }
 
         this.scriptTree = this.getScriptTree();
 
@@ -180,6 +194,10 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         return this.to || this.getScriptAddress();
     }
 
+    public exportCompiledTargetScript(): Buffer {
+        return this.compiledTargetScript;
+    }
+
     /**
      * Get the random bytes used for the interaction
      * @returns {Buffer} The random bytes
@@ -366,6 +384,16 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             });
         }
 
+        if (parameters.revealMLDSAPublicKey && !parameters.linkMLDSAPublicKeyToAddress) {
+            throw new Error(
+                'To reveal the MLDSA public key, you must set linkMLDSAPublicKeyToAddress to true.',
+            );
+        }
+
+        if (parameters.linkMLDSAPublicKeyToAddress) {
+            this.generateMLDSALinkRequest(parameters, features);
+        }
+
         return features;
     }
 

package/src/transaction/builders/InteractionTransaction.ts

@@ -36,13 +36,23 @@ export class InteractionTransaction extends SharedInteractionTransaction<Transac
             throw new Error('Invalid contract secret length. Expected 32 bytes.');
         }
 
-        this.compiledTargetScript = this.calldataGenerator.compile(
-            this.calldata,
-            this.contractSecret,
-            this.challenge,
-            this.priorityFee,
-            this.generateFeatures(parameters),
-        );
+        if (parameters.compiledTargetScript) {
+            if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+                this.compiledTargetScript = parameters.compiledTargetScript;
+            } else if (typeof parameters.compiledTargetScript === 'string') {
+                this.compiledTargetScript = Buffer.from(parameters.compiledTargetScript, 'hex');
+            } else {
+                throw new Error('Invalid compiled target script format.');
+            }
+        } else {
+            this.compiledTargetScript = this.calldataGenerator.compile(
+                this.calldata,
+                this.contractSecret,
+                this.challenge,
+                this.priorityFee,
+                this.generateFeatures(parameters),
+            );
+        }
 
         this.scriptTree = this.getScriptTree();
         this.internalInit();

package/src/transaction/builders/InteractionTransactionP2WDA.ts

@@ -97,13 +97,23 @@ export class InteractionTransactionP2WDA extends TransactionBuilder<TransactionT
         // Validate P2WDA inputs
         this.validateP2WDAInputs();
 
-        this.compiledOperationData = this.p2wdaGenerator.compile(
-            this.calldata,
-            this.contractSecret,
-            this.challenge,
-            this.priorityFee,
-            this.generateFeatures(parameters),
-        );
+        if (parameters.compiledTargetScript) {
+            if (Buffer.isBuffer(parameters.compiledTargetScript)) {
+                this.compiledOperationData = parameters.compiledTargetScript;
+            } else if (typeof parameters.compiledTargetScript === 'string') {
+                this.compiledOperationData = Buffer.from(parameters.compiledTargetScript, 'hex');
+            } else {
+                throw new Error('Invalid compiled target script format.');
+            }
+        } else {
+            this.compiledOperationData = this.p2wdaGenerator.compile(
+                this.calldata,
+                this.contractSecret,
+                this.challenge,
+                this.priorityFee,
+                this.generateFeatures(parameters),
+            );
+        }
 
         // Validate size early
         this.validateOperationDataSize();