@btc-vision/transaction 1.7.7 → 1.7.10

package/src/keypair/Address.ts

@@ -9,6 +9,7 @@ import { TimeLockGenerator } from '../transaction/mineable/TimelockGenerator.js'
 import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 import { P2WDADetector } from '../p2wda/P2WDADetector.js';
 import { sha256 } from '@noble/hashes/sha2';
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
 
 /**
  * Objects of type "Address" represent hashed ML-DSA (quantum) public keys (using SHA256 of quantum keys) and maintain classical public keys separately.
@@ -32,8 +33,10 @@ export class Address extends Uint8Array {
     #mldsaPublicKey: Uint8Array | undefined;
     #cachedBigInt: bigint | undefined;
     #cachedUint64Array: [bigint, bigint, bigint, bigint] | undefined;
+    #originalMDLSAPublicKey: Uint8Array | undefined;
+    #mldsaLevel: MLDSASecurityLevel | undefined;
 
-    private classicPublicKey: Uint8Array | undefined;
+    private legacyPublicKey: Uint8Array | undefined;
 
     public constructor(mldsaPublicKey?: ArrayLike<number>, publicKeyOrTweak?: ArrayLike<number>) {
         super(ADDRESS_BYTE_LENGTH);
@@ -43,13 +46,29 @@ export class Address extends Uint8Array {
         }
 
         if (publicKeyOrTweak) {
-            this.classicPublicKey = new Uint8Array(publicKeyOrTweak.length);
-            this.classicPublicKey.set(publicKeyOrTweak);
+            this.legacyPublicKey = new Uint8Array(publicKeyOrTweak.length);
+            this.legacyPublicKey.set(publicKeyOrTweak);
         }
 
         this.set(mldsaPublicKey);
     }
 
+    public get mldsaLevel(): MLDSASecurityLevel | undefined {
+        return this.#mldsaLevel;
+    }
+
+    public set mldsaLevel(level: MLDSASecurityLevel) {
+        this.#mldsaLevel = level;
+    }
+
+    public get originalMDLSAPublicKey(): Uint8Array | undefined {
+        return this.#originalMDLSAPublicKey;
+    }
+
+    public set originalMDLSAPublicKey(key: Buffer | Uint8Array) {
+        this.#originalMDLSAPublicKey = new Uint8Array(key);
+    }
+
     /**
      * If available, this will return the original public key associated with the address.
      * @returns {Uint8Array} The original public key used to create the address.
@@ -68,7 +87,7 @@ export class Address extends Uint8Array {
      */
     private get keyPair(): ECPairInterface {
         if (!this.#keyPair) {
-            throw new Error('Classical public key not set for address');
+            throw new Error('Legacy public key not set for address');
         }
 
         return this.#keyPair;
@@ -84,10 +103,10 @@ export class Address extends Uint8Array {
     /**
      * Create an address from a hex string
      * @param {string} mldsaPublicKey The ml-dsa public key in hex format
-     * @param {string} classicPublicKey The classical public key in hex format
+     * @param {string} legacyPublicKey The classical public key in hex format
      * @returns {Address} The address
      */
-    public static fromString(mldsaPublicKey: string, classicPublicKey?: string): Address {
+    public static fromString(mldsaPublicKey: string, legacyPublicKey?: string): Address {
         if (!mldsaPublicKey) {
             throw new Error('Invalid public key');
         }
@@ -103,18 +122,18 @@ export class Address extends Uint8Array {
         }
 
         let classicBuffer: Buffer | undefined;
-        if (classicPublicKey) {
-            if (classicPublicKey.startsWith('0x')) {
-                classicPublicKey = classicPublicKey.slice(2);
+        if (legacyPublicKey) {
+            if (legacyPublicKey.startsWith('0x')) {
+                legacyPublicKey = legacyPublicKey.slice(2);
             }
 
-            if (!BitcoinUtils.isValidHex(classicPublicKey)) {
+            if (!BitcoinUtils.isValidHex(legacyPublicKey)) {
                 throw new Error(
                     'You must only pass classical public keys in hexadecimal format. If you have an address such as bc1q... you must convert it to a public key first. Please refer to await provider.getPublicKeyInfo("bc1q..."). If the public key associated with the address is not found, you must force the user to enter the destination public key. It looks like: 0x020373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c.',
                 );
             }
 
-            classicBuffer = Buffer.from(classicPublicKey, 'hex');
+            classicBuffer = Buffer.from(legacyPublicKey, 'hex');
         }
 
         return new Address(Buffer.from(mldsaPublicKey, 'hex'), classicBuffer);
@@ -245,6 +264,20 @@ export class Address extends Uint8Array {
         return this.#cachedUint64Array;
     }
 
+    /**
+     * Check if the address is the dead address
+     * @returns {boolean}
+     */
+    public isDead(): boolean {
+        for (let i = 0; i < ADDRESS_BYTE_LENGTH; i++) {
+            if (this[i] !== 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Converts the address to a hex string
      * @returns {string} The hex string
@@ -258,11 +291,11 @@ export class Address extends Uint8Array {
      * @returns {string} The hex string
      */
     public tweakedToHex(): string {
-        if (!this.classicPublicKey) {
-            throw new Error('Classical public key not set');
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
         }
 
-        return '0x' + Buffer.from(this.classicPublicKey).toString('hex');
+        return '0x' + Buffer.from(this.legacyPublicKey).toString('hex');
     }
 
     /**
@@ -278,16 +311,16 @@ export class Address extends Uint8Array {
      * @returns {Buffer} The buffer
      */
     public tweakedPublicKeyToBuffer(): Buffer {
-        if (!this.classicPublicKey) {
-            throw new Error('Classical public key not set');
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
         }
 
-        return Buffer.from(this.classicPublicKey);
+        return Buffer.from(this.legacyPublicKey);
     }
 
     public toUncompressedHex(): string {
         if (!this.#uncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return '0x' + this.#uncompressed.uncompressed.toString('hex');
@@ -295,7 +328,7 @@ export class Address extends Uint8Array {
 
     public toUncompressedBuffer(): Buffer {
         if (!this.#uncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return this.#uncompressed.uncompressed;
@@ -303,7 +336,7 @@ export class Address extends Uint8Array {
 
     public toHybridPublicKeyHex(): string {
         if (!this.#uncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return '0x' + this.#uncompressed.hybrid.toString('hex');
@@ -311,7 +344,7 @@ export class Address extends Uint8Array {
 
     public toHybridPublicKeyBuffer(): Buffer {
         if (!this.#uncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return this.#uncompressed.hybrid;
@@ -319,7 +352,7 @@ export class Address extends Uint8Array {
 
     public originalPublicKeyBuffer(): Buffer {
         if (!this.#originalPublicKey) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return Buffer.from(this.#originalPublicKey);
@@ -421,19 +454,19 @@ export class Address extends Uint8Array {
      * @returns {void}
      */
     public override set(mldsaPublicKey: ArrayLike<number>): void {
-        if (this.classicPublicKey) {
+        if (this.legacyPublicKey) {
             const validLengths = [ADDRESS_BYTE_LENGTH, 33, 65];
-            if (!validLengths.includes(this.classicPublicKey.length)) {
-                throw new Error(`Invalid public key length ${this.classicPublicKey.length}`);
+            if (!validLengths.includes(this.legacyPublicKey.length)) {
+                throw new Error(`Invalid public key length ${this.legacyPublicKey.length}`);
             }
 
-            if (this.classicPublicKey.length === ADDRESS_BYTE_LENGTH) {
+            if (this.legacyPublicKey.length === ADDRESS_BYTE_LENGTH) {
                 const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
-                buf.set(this.classicPublicKey);
+                buf.set(this.legacyPublicKey);
 
                 this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(buf);
             } else {
-                this.autoFormat(this.classicPublicKey);
+                this.autoFormat(this.legacyPublicKey);
             }
         }
 
@@ -475,8 +508,15 @@ export class Address extends Uint8Array {
      * @param {Network} network The network
      * @returns {boolean} If the public key is valid
      */
-    public isValid(network: Network): boolean {
-        return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
+    public isValidLegacyPublicKey(network: Network): boolean {
+        if (!this.legacyPublicKey) {
+            throw new Error(`Legacy key not set.`);
+        }
+
+        return AddressVerificator.isValidPublicKey(
+            Buffer.from(this.legacyPublicKey).toString('hex'),
+            network,
+        );
     }
 
     /**
@@ -529,8 +569,8 @@ export class Address extends Uint8Array {
      * @param {Network} network The network
      */
     public p2tr(network: Network): string {
-        if (!this.classicPublicKey) {
-            throw new Error('Classical public key not set');
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
         }
 
         if (this.#p2tr && this.#network === network) {
@@ -538,7 +578,7 @@ export class Address extends Uint8Array {
         }
 
         const p2trAddy: string | undefined = EcKeyPair.tweakedPubKeyBufferToAddress(
-            this.classicPublicKey,
+            this.legacyPublicKey,
             network,
         );
 
@@ -549,7 +589,7 @@ export class Address extends Uint8Array {
             return p2trAddy;
         }
 
-        throw new Error('Classical public key not set');
+        throw new Error('Legacy public key not set');
     }
 
     /**
@@ -665,7 +705,7 @@ export class Address extends Uint8Array {
 
     public toTweakedHybridPublicKeyHex(): string {
         if (!this.#tweakedUncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return '0x' + this.#tweakedUncompressed.toString('hex');
@@ -673,7 +713,7 @@ export class Address extends Uint8Array {
 
     public toTweakedHybridPublicKeyBuffer(): Buffer {
         if (!this.#tweakedUncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return this.#tweakedUncompressed;
@@ -699,7 +739,7 @@ export class Address extends Uint8Array {
 
         this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(tweakedBytes);
 
-        this.classicPublicKey = new Uint8Array(ADDRESS_BYTE_LENGTH);
-        this.classicPublicKey.set(tweakedBytes);
+        this.legacyPublicKey = new Uint8Array(ADDRESS_BYTE_LENGTH);
+        this.legacyPublicKey.set(tweakedBytes);
     }
 }

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';

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,