@btc-vision/transaction 1.7.7 → 1.7.10

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();

package/src/transaction/builders/TransactionBuilder.ts

@@ -27,6 +27,12 @@ import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { IP2WSHAddress } from '../mineable/IP2WSHAddress.js';
 import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+import { Feature, Features, MLDSALinkRequest } from '../../generators/Features.js';
+import { BITCOIN_PROTOCOL_ID, getChainId } from '../../chain/ChainData.js';
+import { BinaryWriter } from '../../buffer/BinaryWriter.js';
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
+import { MessageSigner } from '../../keypair/MessageSigner.js';
+import { getLevelFromPublicKeyLength } from '../../generators/MLDSAData.js';
 
 initEccLib(ecc);
 
@@ -288,6 +294,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             amount: this.estimatedFees,
             optionalOutputs: this.optionalOutputs,
             optionalInputs: this.optionalInputs,
+            mldsaSigner: null,
         };
     }
 
@@ -874,6 +881,106 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         throw new Error('Output not found');
     }
 
+    protected generateLegacySignature(): Buffer {
+        this.tweakSigner();
+
+        if (!this.tweakedSigner) {
+            throw new Error('Tweaked signer is not defined');
+        }
+
+        const tweakedKey = toXOnly(this.tweakedSigner.publicKey);
+        const chainId = getChainId(this.network);
+
+        const writer = new BinaryWriter();
+
+        // ONLY SUPPORT MLDSA-44 FOR NOW.
+        writer.writeU8(MLDSASecurityLevel.LEVEL2);
+        writer.writeBytes(this.hashedPublicKey);
+        writer.writeBytes(tweakedKey);
+        writer.writeBytes(BITCOIN_PROTOCOL_ID);
+        writer.writeBytes(chainId);
+
+        const message = writer.getBuffer();
+        const signature = MessageSigner.signMessage(this.tweakedSigner, message);
+        const isValid = MessageSigner.verifySignature(tweakedKey, message, signature.signature);
+
+        if (!isValid) {
+            throw new Error('Could not verify generated legacy signature for MLDSA link request');
+        }
+
+        return Buffer.from(signature.signature);
+    }
+
+    protected generateMLDSASignature(): Buffer {
+        if (!this.mldsaSigner) {
+            throw new Error('MLDSA signer is not defined');
+        }
+
+        this.tweakSigner();
+
+        if (!this.tweakedSigner) {
+            throw new Error('Tweaked signer is not defined');
+        }
+
+        const tweakedKey = toXOnly(this.tweakedSigner.publicKey);
+        const chainId = getChainId(this.network);
+        const level = getLevelFromPublicKeyLength(this.mldsaSigner.publicKey.length);
+
+        if (level !== MLDSASecurityLevel.LEVEL2) {
+            throw new Error('Only MLDSA level 2 is supported for link requests');
+        }
+
+        const writer = new BinaryWriter();
+        writer.writeU8(level);
+        writer.writeBytes(this.hashedPublicKey);
+        writer.writeBytes(this.mldsaSigner.publicKey);
+        writer.writeBytes(tweakedKey);
+        writer.writeBytes(BITCOIN_PROTOCOL_ID);
+        writer.writeBytes(chainId);
+
+        const message = writer.getBuffer();
+        const signature = MessageSigner.signMLDSAMessage(this.mldsaSigner, message);
+
+        const isValid = MessageSigner.verifyMLDSASignature(
+            this.mldsaSigner,
+            message,
+            signature.signature,
+        );
+
+        if (!isValid) {
+            throw new Error('Could not verify generated MLDSA signature for link request');
+        }
+
+        return Buffer.from(signature.signature);
+    }
+
+    protected generateMLDSALinkRequest(
+        parameters: ITransactionParameters,
+        features: Feature<Features>[],
+    ): void {
+        const mldsaSigner = this.mldsaSigner;
+        const legacySignature = this.generateLegacySignature();
+
+        let mldsaSignature: Buffer | null = null;
+        if (parameters.revealMLDSAPublicKey) {
+            mldsaSignature = this.generateMLDSASignature();
+        }
+
+        const mldsaRequest: MLDSALinkRequest = {
+            opcode: Features.MLDSA_LINK_PUBKEY,
+            data: {
+                verifyRequest: !!parameters.revealMLDSAPublicKey,
+                publicKey: mldsaSigner.publicKey,
+                hashedPublicKey: this.hashedPublicKey,
+                level: getLevelFromPublicKeyLength(mldsaSigner.publicKey.length),
+                legacySignature: legacySignature,
+                mldsaSignature: mldsaSignature,
+            },
+        };
+
+        features.push(mldsaRequest);
+    }
+
     /**
      * @description Returns the transaction opnet fee
      * @protected

package/src/transaction/interfaces/ITransactionParameters.ts

@@ -13,6 +13,16 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     readonly to?: string;
     readonly debugFees?: boolean;
 
+    /**
+     * Reveal this user's MLDSA public key in the transaction features.
+     */
+    readonly revealMLDSAPublicKey?: boolean;
+
+    /**
+     * Link the user MLDSA public key to their legacy public key.
+     */
+    readonly linkMLDSAPublicKeyToAddress?: boolean;
+
     utxos: UTXO[];
 
     nonWitnessUtxo?: Buffer;
@@ -30,6 +40,8 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     readonly feeRate: number;
     readonly priorityFee: bigint;
     readonly gasSatFee: bigint;
+
+    readonly compiledTargetScript?: Buffer | string;
 }
 
 export interface IFundingTransactionParameters extends ITransactionParameters {

package/src/transaction/shared/P2TR_MS.ts

@@ -29,6 +29,7 @@ export class P2TR_MS {
             receiver: 'a',
             requestedAmount: 1n,
             refundVault: 'a',
+            mldsaSigner: null,
         };
 
         const address = new MultiSignTransaction(multiSignParams).getScriptAddress();

package/src/transaction/shared/TweakedTransaction.ts

@@ -41,10 +41,13 @@ import {
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
 import { Buffer } from 'buffer';
 import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+import { QuantumBIP32Interface } from '@btc-vision/bip32';
+import { MessageSigner } from '../../keypair/MessageSigner.js';
 
 export type SupportedTransactionVersion = 1 | 2 | 3;
 
 export interface ITweakedTransactionData {
+    readonly mldsaSigner: QuantumBIP32Interface | null;
     readonly signer: Signer | ECPairInterface | UnisatSigner;
     readonly network: Network;
     readonly chainId?: ChainId;
@@ -161,6 +164,9 @@ export abstract class TweakedTransaction extends Logger {
 
     protected txVersion: SupportedTransactionVersion = 2;
 
+    protected readonly _mldsaSigner: QuantumBIP32Interface | null = null;
+    protected readonly _hashedPublicKey: Buffer | null = null;
+
     protected constructor(data: ITweakedTransactionData) {
         super();
 
@@ -176,6 +182,35 @@ export abstract class TweakedTransaction extends Logger {
         if (data.txVersion) {
             this.txVersion = data.txVersion;
         }
+
+        if (data.mldsaSigner) {
+            this._mldsaSigner = data.mldsaSigner;
+            this._hashedPublicKey = MessageSigner.sha256(this._mldsaSigner.publicKey);
+        }
+    }
+
+    /**
+     * Get the MLDSA signer
+     * @protected
+     */
+    protected get mldsaSigner(): QuantumBIP32Interface {
+        if (!this._mldsaSigner) {
+            throw new Error('MLDSA Signer is not set');
+        }
+
+        return this._mldsaSigner;
+    }
+
+    /**
+     * Get the hashed public key
+     * @protected
+     */
+    protected get hashedPublicKey(): Buffer {
+        if (!this._hashedPublicKey) {
+            throw new Error('Hashed public key is not set');
+        }
+
+        return this._hashedPublicKey;
     }
 
     /**

package/src/utxo/OPNetLimitedProvider.ts

@@ -12,6 +12,7 @@ export interface WalletUTXOs {
     readonly confirmed: RawUTXOResponse[];
     readonly pending: RawUTXOResponse[];
     readonly spentTransactions: RawUTXOResponse[];
+    readonly raw: string[];
 }
 
 /**
@@ -53,6 +54,8 @@ export class OPNetLimitedProvider {
         }
 
         const fetchedData: WalletUTXOs = (await resp.json()) as WalletUTXOs;
+        const rawTransactions = fetchedData.raw ?? [];
+
         const allUtxos = settings.usePendingUTXO
             ? [...fetchedData.confirmed, ...fetchedData.pending]
             : fetchedData.confirmed;
@@ -91,18 +94,31 @@ export class OPNetLimitedProvider {
         for (const utxo of meetCriteria) {
             const utxoValue: bigint = BigInt(utxo.value);
 
-            // check if value is greater than 0
             if (utxoValue <= 0n) {
                 continue;
             }
 
+            const rawIndex = utxo.raw as unknown as number;
+            if (rawIndex === undefined || rawIndex === null) {
+                throw new Error(
+                    `Missing raw index for UTXO ${utxo.transactionId}:${utxo.outputIndex}`,
+                );
+            }
+
+            const rawHex = rawTransactions[rawIndex];
+            if (!rawHex) {
+                throw new Error(
+                    `Invalid raw index ${rawIndex} - not found in raw transactions array`,
+                );
+            }
+
             currentAmount += utxoValue;
             finalUTXOs.push({
                 transactionId: utxo.transactionId,
                 outputIndex: utxo.outputIndex,
                 value: utxoValue,
                 scriptPubKey: utxo.scriptPubKey,
-                nonWitnessUtxo: Buffer.from(utxo.raw, 'base64'),
+                nonWitnessUtxo: Buffer.from(rawHex, 'base64'),
             });
 
             if (currentAmount > amountRequested) {
@@ -213,6 +229,7 @@ export class OPNetLimitedProvider {
             splitInputsInto,
             priorityFee: 0n,
             gasSatFee: 330n,
+            mldsaSigner: null,
         };
 
         const transactionFactory = new TransactionFactory();