@btc-vision/transaction 1.7.7 → 1.7.10

package/build/keypair/Address.js

@@ -9,7 +9,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _Address_p2tr, _Address_p2op, _Address_network, _Address_originalPublicKey, _Address_keyPair, _Address_uncompressed, _Address_tweakedUncompressed, _Address_p2wda, _Address_mldsaPublicKey, _Address_cachedBigInt, _Address_cachedUint64Array;
+var _Address_p2tr, _Address_p2op, _Address_network, _Address_originalPublicKey, _Address_keyPair, _Address_uncompressed, _Address_tweakedUncompressed, _Address_p2wda, _Address_mldsaPublicKey, _Address_cachedBigInt, _Address_cachedUint64Array, _Address_originalMDLSAPublicKey, _Address_mldsaLevel;
 import { decompressPublicKey, toXOnly } from '@btc-vision/bitcoin';
 import { ADDRESS_BYTE_LENGTH } from '../utils/lengths.js';
 import { AddressVerificator } from './AddressVerificator.js';
@@ -33,15 +33,29 @@ export class Address extends Uint8Array {
         _Address_mldsaPublicKey.set(this, void 0);
         _Address_cachedBigInt.set(this, void 0);
         _Address_cachedUint64Array.set(this, void 0);
+        _Address_originalMDLSAPublicKey.set(this, void 0);
+        _Address_mldsaLevel.set(this, void 0);
         if (!mldsaPublicKey) {
             return;
         }
         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);
     }
+    get mldsaLevel() {
+        return __classPrivateFieldGet(this, _Address_mldsaLevel, "f");
+    }
+    set mldsaLevel(level) {
+        __classPrivateFieldSet(this, _Address_mldsaLevel, level, "f");
+    }
+    get originalMDLSAPublicKey() {
+        return __classPrivateFieldGet(this, _Address_originalMDLSAPublicKey, "f");
+    }
+    set originalMDLSAPublicKey(key) {
+        __classPrivateFieldSet(this, _Address_originalMDLSAPublicKey, new Uint8Array(key), "f");
+    }
     get originalPublicKey() {
         return __classPrivateFieldGet(this, _Address_originalPublicKey, "f");
     }
@@ -50,14 +64,14 @@ export class Address extends Uint8Array {
     }
     get keyPair() {
         if (!__classPrivateFieldGet(this, _Address_keyPair, "f")) {
-            throw new Error('Classical public key not set for address');
+            throw new Error('Legacy public key not set for address');
         }
         return __classPrivateFieldGet(this, _Address_keyPair, "f");
     }
     static dead() {
         return Address.fromString('0x0000000000000000000000000000000000000000000000000000000000000000', '0x04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f');
     }
-    static fromString(mldsaPublicKey, classicPublicKey) {
+    static fromString(mldsaPublicKey, legacyPublicKey) {
         if (!mldsaPublicKey) {
             throw new Error('Invalid public key');
         }
@@ -68,14 +82,14 @@ export class Address extends Uint8Array {
             throw new Error('You must only pass 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.');
         }
         let classicBuffer;
-        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);
     }
@@ -122,51 +136,59 @@ export class Address extends Uint8Array {
         ], "f");
         return __classPrivateFieldGet(this, _Address_cachedUint64Array, "f");
     }
+    isDead() {
+        for (let i = 0; i < ADDRESS_BYTE_LENGTH; i++) {
+            if (this[i] !== 0) {
+                return false;
+            }
+        }
+        return true;
+    }
     toHex() {
         return '0x' + Buffer.from(this).toString('hex');
     }
     tweakedToHex() {
-        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');
     }
     toBuffer() {
         return Buffer.from(this);
     }
     tweakedPublicKeyToBuffer() {
-        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);
     }
     toUncompressedHex() {
         if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
         return '0x' + __classPrivateFieldGet(this, _Address_uncompressed, "f").uncompressed.toString('hex');
     }
     toUncompressedBuffer() {
         if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
         return __classPrivateFieldGet(this, _Address_uncompressed, "f").uncompressed;
     }
     toHybridPublicKeyHex() {
         if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
         return '0x' + __classPrivateFieldGet(this, _Address_uncompressed, "f").hybrid.toString('hex');
     }
     toHybridPublicKeyBuffer() {
         if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
         return __classPrivateFieldGet(this, _Address_uncompressed, "f").hybrid;
     }
     originalPublicKeyBuffer() {
         if (!__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
         return Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"));
     }
@@ -222,18 +244,18 @@ export class Address extends Uint8Array {
         return false;
     }
     set(mldsaPublicKey) {
-        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);
                 __classPrivateFieldSet(this, _Address_tweakedUncompressed, ContractAddress.generateHybridKeyFromHash(buf), "f");
             }
             else {
-                this.autoFormat(this.classicPublicKey);
+                this.autoFormat(this.legacyPublicKey);
             }
         }
         if (mldsaPublicKey.length === ADDRESS_BYTE_LENGTH) {
@@ -255,8 +277,11 @@ export class Address extends Uint8Array {
             super.set(buf);
         }
     }
-    isValid(network) {
-        return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
+    isValidLegacyPublicKey(network) {
+        if (!this.legacyPublicKey) {
+            throw new Error(`Legacy key not set.`);
+        }
+        return AddressVerificator.isValidPublicKey(Buffer.from(this.legacyPublicKey).toString('hex'), network);
     }
     p2pk() {
         return this.toHex();
@@ -277,19 +302,19 @@ export class Address extends Uint8Array {
         return this.toHex();
     }
     p2tr(network) {
-        if (!this.classicPublicKey) {
-            throw new Error('Classical public key not set');
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
         }
         if (__classPrivateFieldGet(this, _Address_p2tr, "f") && __classPrivateFieldGet(this, _Address_network, "f") === network) {
             return __classPrivateFieldGet(this, _Address_p2tr, "f");
         }
-        const p2trAddy = EcKeyPair.tweakedPubKeyBufferToAddress(this.classicPublicKey, network);
+        const p2trAddy = EcKeyPair.tweakedPubKeyBufferToAddress(this.legacyPublicKey, network);
         if (p2trAddy) {
             __classPrivateFieldSet(this, _Address_network, network, "f");
             __classPrivateFieldSet(this, _Address_p2tr, p2trAddy, "f");
             return p2trAddy;
         }
-        throw new Error('Classical public key not set');
+        throw new Error('Legacy public key not set');
     }
     p2wda(network) {
         if (__classPrivateFieldGet(this, _Address_p2wda, "f") && __classPrivateFieldGet(this, _Address_network, "f") === network) {
@@ -340,13 +365,13 @@ export class Address extends Uint8Array {
     }
     toTweakedHybridPublicKeyHex() {
         if (!__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f")) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
         return '0x' + __classPrivateFieldGet(this, _Address_tweakedUncompressed, "f").toString('hex');
     }
     toTweakedHybridPublicKeyBuffer() {
         if (!__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f")) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
         return __classPrivateFieldGet(this, _Address_tweakedUncompressed, "f");
     }
@@ -362,8 +387,8 @@ export class Address extends Uint8Array {
         __classPrivateFieldSet(this, _Address_uncompressed, decompressPublicKey(__classPrivateFieldGet(this, _Address_originalPublicKey, "f")), "f");
         const tweakedBytes = toXOnly(EcKeyPair.tweakPublicKey(Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"))));
         __classPrivateFieldSet(this, _Address_tweakedUncompressed, ContractAddress.generateHybridKeyFromHash(tweakedBytes), "f");
-        this.classicPublicKey = new Uint8Array(ADDRESS_BYTE_LENGTH);
-        this.classicPublicKey.set(tweakedBytes);
+        this.legacyPublicKey = new Uint8Array(ADDRESS_BYTE_LENGTH);
+        this.legacyPublicKey.set(tweakedBytes);
     }
 }
-_Address_p2tr = new WeakMap(), _Address_p2op = new WeakMap(), _Address_network = new WeakMap(), _Address_originalPublicKey = new WeakMap(), _Address_keyPair = new WeakMap(), _Address_uncompressed = new WeakMap(), _Address_tweakedUncompressed = new WeakMap(), _Address_p2wda = new WeakMap(), _Address_mldsaPublicKey = new WeakMap(), _Address_cachedBigInt = new WeakMap(), _Address_cachedUint64Array = new WeakMap();
+_Address_p2tr = new WeakMap(), _Address_p2op = new WeakMap(), _Address_network = new WeakMap(), _Address_originalPublicKey = new WeakMap(), _Address_keyPair = new WeakMap(), _Address_uncompressed = new WeakMap(), _Address_tweakedUncompressed = new WeakMap(), _Address_p2wda = new WeakMap(), _Address_mldsaPublicKey = new WeakMap(), _Address_cachedBigInt = new WeakMap(), _Address_cachedUint64Array = new WeakMap(), _Address_originalMDLSAPublicKey = new WeakMap(), _Address_mldsaLevel = new WeakMap();

package/build/keypair/MessageSigner.d.ts

@@ -13,12 +13,21 @@ export interface MLDSASignedMessage {
 }
 declare class MessageSignerBase {
     sha256(message: Buffer | Uint8Array): Buffer;
+    trySignSchnorrWithOPWallet(message: Uint8Array | Buffer | string): Promise<SignedMessage | null>;
+    trySignMLDSAWithOPWallet(message: Uint8Array | Buffer | string): Promise<MLDSASignedMessage | null>;
+    signMessageAuto(message: Uint8Array | Buffer | string, keypair?: ECPairInterface): Promise<SignedMessage>;
+    tweakAndSignMessageAuto(message: Uint8Array | Buffer | string, keypair?: ECPairInterface, network?: Network): Promise<SignedMessage>;
+    signMLDSAMessageAuto(message: Uint8Array | Buffer | string, mldsaKeypair?: QuantumBIP32Interface): Promise<MLDSASignedMessage>;
+    verifyMLDSAWithOPWallet(message: Uint8Array | Buffer | string, signature: MLDSASignedMessage): Promise<boolean | null>;
+    getMLDSAPublicKeyFromOPWallet(): Promise<Buffer | null>;
     tweakAndSignMessage(keypair: ECPairInterface, message: Uint8Array | Buffer | string, network: Network): SignedMessage;
     signMessage(keypair: ECPairInterface, message: Uint8Array | Buffer | string): SignedMessage;
     verifySignature(publicKey: Uint8Array | Buffer, message: Uint8Array | Buffer | string, signature: Uint8Array | Buffer): boolean;
     tweakAndVerifySignature(publicKey: Uint8Array | Buffer, message: Uint8Array | Buffer | string, signature: Uint8Array | Buffer): boolean;
     signMLDSAMessage(mldsaKeypair: QuantumBIP32Interface, message: Uint8Array | Buffer | string): MLDSASignedMessage;
     verifyMLDSASignature(mldsaKeypair: QuantumBIP32Interface, message: Uint8Array | Buffer | string, signature: Uint8Array | Buffer): boolean;
+    isOPWalletAvailable(): boolean;
+    private getOPWallet;
 }
 export declare const MessageSigner: MessageSignerBase;
 export {};

package/build/keypair/MessageSigner.js

@@ -2,14 +2,99 @@ import * as ecc from '@bitcoinerlab/secp256k1';
 import { crypto, toXOnly } from '@btc-vision/bitcoin';
 import { TweakedSigner } from '../signer/TweakedSigner.js';
 import { EcKeyPair } from './EcKeyPair.js';
+import { isOPWallet } from '../transaction/browser/types/OPWallet.js';
 class MessageSignerBase {
     sha256(message) {
         return crypto.sha256(Buffer.from(message));
     }
+    async trySignSchnorrWithOPWallet(message) {
+        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,
+        };
+    }
+    async trySignMLDSAWithOPWallet(message) {
+        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 = await wallet.web3.signMLDSAMessage(messageHex);
+        return {
+            signature: Buffer.from(result.signature, 'hex'),
+            message: hashedMessage,
+            publicKey: Buffer.from(result.publicKey, 'hex'),
+            securityLevel: result.securityLevel,
+        };
+    }
+    async signMessageAuto(message, keypair) {
+        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);
+    }
+    async tweakAndSignMessageAuto(message, keypair, network) {
+        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);
+    }
+    async signMLDSAMessageAuto(message, mldsaKeypair) {
+        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);
+    }
+    async verifyMLDSAWithOPWallet(message, signature) {
+        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 = {
+            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);
+    }
+    async getMLDSAPublicKeyFromOPWallet() {
+        const wallet = this.getOPWallet();
+        if (!wallet) {
+            return null;
+        }
+        const publicKeyHex = await wallet.web3.getMLDSAPublicKey();
+        return Buffer.from(publicKeyHex, 'hex');
+    }
     tweakAndSignMessage(keypair, message, network) {
-        const tweaked = TweakedSigner.tweakSigner(keypair, {
-            network,
-        });
+        const tweaked = TweakedSigner.tweakSigner(keypair, { network });
         return this.signMessage(tweaked, message);
     }
     signMessage(keypair, message) {
@@ -62,5 +147,18 @@ class MessageSignerBase {
         const hashedMessage = this.sha256(message);
         return mldsaKeypair.verify(hashedMessage, signature);
     }
+    isOPWalletAvailable() {
+        return this.getOPWallet() !== null;
+    }
+    getOPWallet() {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        const _window = window;
+        if (!_window.opnet || !isOPWallet(_window.opnet)) {
+            return null;
+        }
+        return _window.opnet;
+    }
 }
 export const MessageSigner = new MessageSignerBase();

package/build/opnet.d.ts

@@ -23,6 +23,7 @@ export * from './mnemonic/Mnemonic.js';
 export * from './mnemonic/MnemonicStrength.js';
 export * from './mnemonic/BIPStandard.js';
 export { MLDSASecurityLevel, MLDSAKeyPair, QuantumBIP32Interface, QuantumBIP32API, QuantumSigner, QuantumBIP32Factory, QuantumDerivationPath, } from '@btc-vision/bip32';
+export * from './generators/MLDSAData.js';
 export * from './metadata/ContractBaseMetadata.js';
 export * from './network/ChainId.js';
 export * from './signer/TweakedSigner.js';

package/build/opnet.js

@@ -22,6 +22,7 @@ export * from './mnemonic/Mnemonic.js';
 export * from './mnemonic/MnemonicStrength.js';
 export * from './mnemonic/BIPStandard.js';
 export { MLDSASecurityLevel, QuantumBIP32Factory, QuantumDerivationPath, } from '@btc-vision/bip32';
+export * from './generators/MLDSAData.js';
 export * from './metadata/ContractBaseMetadata.js';
 export * from './network/ChainId.js';
 export * from './signer/TweakedSigner.js';

package/build/transaction/TransactionFactory.js

@@ -92,6 +92,7 @@ export class TransactionFactory {
             randomBytes: finalTransaction.getRndBytes(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: finalTransaction.estimatedFees,
+            compiledTargetScript: finalTransaction.exportCompiledTargetScript(),
             optionalInputs: inputs,
         };
         const customTransaction = new CustomScriptTransaction(newParams);
@@ -158,6 +159,7 @@ export class TransactionFactory {
             utxos: fundingUTXO,
             randomBytes: finalTransaction.getRndBytes(),
             challenge: challenge,
+            compiledTargetScript: finalTransaction.exportCompiledTargetScript(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: finalTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -228,6 +230,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo],
             randomBytes: finalTransaction.getRndBytes(),
+            compiledTargetScript: finalTransaction.exportCompiledTargetScript(),
             challenge: challenge,
             nonWitnessUtxo: signedTransaction.toBuffer(),
             estimatedFees: finalTransaction.estimatedFees,

package/build/transaction/browser/Web3Provider.d.ts

@@ -3,10 +3,11 @@ 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';
-export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer' | 'challenge'>;
-export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network' | 'challenge'>;
-export type ICustomTransactionWithoutSigner = Omit<ICustomTransactionParameters, 'signer' | 'challenge'>;
-export type ICancelTransactionParametersWithoutSigner = Omit<ICancelTransactionParameters, 'signer' | 'challenge' | 'network'>;
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
+export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer' | 'challenge' | 'mldsaSigner'>;
+export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network' | 'challenge' | 'mldsaSigner'>;
+export type ICustomTransactionWithoutSigner = Omit<ICustomTransactionParameters, 'signer' | 'challenge' | 'mldsaSigner'>;
+export type ICancelTransactionParametersWithoutSigner = Omit<ICancelTransactionParameters, 'signer' | 'challenge' | 'network' | 'mldsaSigner'>;
 export interface BroadcastTransactionOptions {
     raw: string;
     psbt: boolean;
@@ -17,6 +18,12 @@ export interface BroadcastedTransaction {
     readonly error?: string;
     readonly peers?: number;
 }
+export interface MLDSASignature {
+    readonly signature: string;
+    readonly publicKey: string;
+    readonly securityLevel: MLDSASecurityLevel;
+    readonly messageHash: string;
+}
 export interface Web3Provider {
     signInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<InteractionResponse>;
     signAndBroadcastInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[], string]>;
@@ -24,4 +31,8 @@ export interface Web3Provider {
     customTransaction(params: ICustomTransactionWithoutSigner): Promise<BroadcastedTransaction>;
     deployContract(params: IDeploymentParametersWithoutSigner): Promise<DeploymentResult>;
     broadcast(transactions: BroadcastTransactionOptions[]): Promise<BroadcastedTransaction[]>;
+    signSchnorr(message: string): Promise<string>;
+    getMLDSAPublicKey(): Promise<string>;
+    signMLDSAMessage(message: string): Promise<MLDSASignature>;
+    verifyMLDSASignature(message: string, signature: MLDSASignature): Promise<boolean>;
 }

package/build/transaction/browser/types/OPWallet.d.ts

@@ -1,14 +1,6 @@
 import { Unisat } from './Unisat.js';
-import { MLDSASecurityLevel } from '@btc-vision/bip32';
-export interface MLDSASignature {
-    readonly signature: string;
-    readonly publicKey: string;
-    readonly securityLevel: MLDSASecurityLevel;
-    readonly messageHash: string;
-}
+import { Web3Provider } from '../Web3Provider.js';
 export interface OPWallet extends Unisat {
-    getMLDSAPublicKey(): Promise<string>;
-    signMLDSAMessage(message: string): Promise<MLDSASignature>;
-    verifyMLDSASignature(message: string, signature: MLDSASignature): Promise<boolean>;
+    web3: Web3Provider;
 }
 export declare function isOPWallet(wallet: unknown): wallet is OPWallet;

package/build/transaction/browser/types/OPWallet.js

@@ -1,6 +1,8 @@
 export function isOPWallet(wallet) {
     return (typeof wallet === 'object' &&
         wallet !== null &&
-        'getMLDSAPublicKey' in wallet &&
-        'signMLDSAMessage' in wallet);
+        'web3' in wallet &&
+        typeof wallet.web3 === 'object' &&
+        'getMLDSAPublicKey' in wallet.web3 &&
+        'signMLDSAMessage' in wallet.web3);
 }

package/build/transaction/builders/CustomScriptTransaction.d.ts

@@ -26,6 +26,7 @@ export declare class CustomScriptTransaction extends TransactionBuilder<Transact
     constructor(parameters: ICustomTransactionParameters);
     get scriptAddress(): string;
     get p2trAddress(): string;
+    exportCompiledTargetScript(): Buffer;
     getRndBytes(): Buffer;
     protected contractSignerXOnlyPubKey(): Buffer;
     protected buildTransaction(): Promise<void>;

package/build/transaction/builders/CustomScriptTransaction.js

@@ -51,6 +51,9 @@ export class CustomScriptTransaction extends TransactionBuilder {
     get p2trAddress() {
         return this.to || this.getScriptAddress();
     }
+    exportCompiledTargetScript() {
+        return this.compiledTargetScript;
+    }
     getRndBytes() {
         return this.randomBytes;
     }

package/build/transaction/builders/DeploymentTransaction.d.ts

@@ -30,6 +30,7 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     get contractPubKey(): string;
     get contractAddress(): Address;
     get p2trAddress(): string;
+    exportCompiledTargetScript(): Buffer;
     getRndBytes(): Buffer;
     getChallenge(): ChallengeSolution;
     getContractAddress(): string;

package/build/transaction/builders/DeploymentTransaction.js

@@ -36,6 +36,9 @@ export class DeploymentTransaction extends TransactionBuilder {
                 finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witness),
             };
         };
+        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();
         if (parameters.calldata) {
@@ -51,7 +54,20 @@ export class DeploymentTransaction extends TransactionBuilder {
         this.contractSeed = this.getContractSeed();
         this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
         this.deploymentGenerator = new DeploymentGenerator(Buffer.from(this.signer.publicKey), this.contractSignerXOnlyPubKey(), 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();
         this.internalInit();
         this._contractPubKey = '0x' + this.contractSeed.toString('hex');
@@ -66,6 +82,9 @@ export class DeploymentTransaction extends TransactionBuilder {
     get p2trAddress() {
         return this.to || this.getScriptAddress();
     }
+    exportCompiledTargetScript() {
+        return this.compiledTargetScript;
+    }
     getRndBytes() {
         return this.randomBytes;
     }
@@ -187,6 +206,12 @@ export class DeploymentTransaction extends TransactionBuilder {
                 data: submission,
             });
         }
+        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;
     }
     verifyCalldata() {

package/build/transaction/builders/InteractionTransaction.js

@@ -13,7 +13,20 @@ export class InteractionTransaction extends SharedInteractionTransaction {
         if (this.contractSecret.length !== 32) {
             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/build/transaction/builders/InteractionTransactionP2WDA.js

@@ -41,7 +41,20 @@ export class InteractionTransactionP2WDA extends TransactionBuilder {
         }
         this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(this.challenge.publicKey.originalPublicKeyBuffer(), this.network);
         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));
+        }
         this.validateOperationDataSize();
         this.internalInit();
     }

package/build/transaction/builders/TransactionBuilder.d.ts

@@ -7,6 +7,7 @@ import { ECPairInterface } from 'ecpair';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
+import { Feature, Features } from '../../generators/Features.js';
 export declare const MINIMUM_AMOUNT_REWARD: bigint;
 export declare const MINIMUM_AMOUNT_CA: bigint;
 export declare const ANCHOR_SCRIPT: Buffer<ArrayBuffer>;
@@ -64,6 +65,9 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected addRefundOutput(amountSpent: bigint, expectRefund?: boolean): Promise<void>;
     protected defineLockScript(): Buffer;
     protected addValueToToOutput(value: number | bigint): void;
+    protected generateLegacySignature(): Buffer;
+    protected generateMLDSASignature(): Buffer;
+    protected generateMLDSALinkRequest(parameters: ITransactionParameters, features: Feature<Features>[]): void;
     protected getTransactionOPNetFee(): bigint;
     protected calculateTotalUTXOAmount(): bigint;
     protected calculateTotalVOutAmount(): bigint;