@btc-vision/transaction 1.7.6 → 1.7.10

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

package/test/address.test.ts

@@ -311,7 +311,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.tweakedToHex()).toThrow('Classical public key not set');
+            expect(() => address.tweakedToHex()).toThrow('Legacy public key not set');
         });
 
         it('should convert tweaked public key to buffer', () => {
@@ -326,9 +326,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.tweakedPublicKeyToBuffer()).toThrow(
-                'Classical public key not set',
-            );
+            expect(() => address.tweakedPublicKeyToBuffer()).toThrow('Legacy public key not set');
         });
 
         it('should get toTweakedHybridPublicKeyHex', () => {
@@ -343,7 +341,7 @@ describe('Address - Comprehensive Tests', () => {
             const address = new Address(mldsaHash);
 
             expect(() => address.toTweakedHybridPublicKeyHex()).toThrow(
-                'Classical public key not set',
+                'Legacy public key not set',
             );
         });
 
@@ -359,7 +357,7 @@ describe('Address - Comprehensive Tests', () => {
             const address = new Address(mldsaHash);
 
             expect(() => address.toTweakedHybridPublicKeyBuffer()).toThrow(
-                'Classical public key not set',
+                'Legacy public key not set',
             );
         });
     });
@@ -376,7 +374,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.toUncompressedHex()).toThrow('Classical public key not set');
+            expect(() => address.toUncompressedHex()).toThrow('Legacy public key not set');
         });
 
         it('should get uncompressed buffer', () => {
@@ -391,7 +389,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.toUncompressedBuffer()).toThrow('Classical public key not set');
+            expect(() => address.toUncompressedBuffer()).toThrow('Legacy public key not set');
         });
 
         it('should get hybrid public key hex', () => {
@@ -405,7 +403,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.toHybridPublicKeyHex()).toThrow('Classical public key not set');
+            expect(() => address.toHybridPublicKeyHex()).toThrow('Legacy public key not set');
         });
 
         it('should get hybrid public key buffer', () => {
@@ -419,7 +417,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.toHybridPublicKeyBuffer()).toThrow('Classical public key not set');
+            expect(() => address.toHybridPublicKeyBuffer()).toThrow('Legacy public key not set');
         });
 
         it('should get original public key buffer', () => {
@@ -434,7 +432,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.originalPublicKeyBuffer()).toThrow('Classical public key not set');
+            expect(() => address.originalPublicKeyBuffer()).toThrow('Legacy public key not set');
         });
     });
 
@@ -646,7 +644,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.p2wpkh(networks.bitcoin)).toThrow('Classical public key not set');
+            expect(() => address.p2wpkh(networks.bitcoin)).toThrow('Legacy public key not set');
         });
     });
 
@@ -676,7 +674,7 @@ describe('Address - Comprehensive Tests', () => {
             const address = new Address(mldsaHash);
 
             expect(() => address.p2pkh(networks.bitcoin)).toThrow(
-                'Classical public key not set for address',
+                'Legacy public key not set for address',
             );
         });
     });
@@ -707,7 +705,7 @@ describe('Address - Comprehensive Tests', () => {
             const address = new Address(mldsaHash);
 
             expect(() => address.p2shp2wpkh(networks.bitcoin)).toThrow(
-                'Classical public key not set for address',
+                'Legacy public key not set for address',
             );
         });
     });
@@ -759,7 +757,7 @@ describe('Address - Comprehensive Tests', () => {
             const mldsaHash = Buffer.alloc(32, 0x01);
             const address = new Address(mldsaHash);
 
-            expect(() => address.p2tr(networks.bitcoin)).toThrow('Classical public key not set');
+            expect(() => address.p2tr(networks.bitcoin)).toThrow('Legacy public key not set');
         });
     });
 
@@ -921,12 +919,12 @@ describe('Address - Comprehensive Tests', () => {
         });
     });
 
-    describe('isValid Method', () => {
+    describe('isValidLegacyPublicKey Method', () => {
         it('should validate address on mainnet', () => {
             const addr = getValidAddress();
-            const isValid = addr.isValid(networks.bitcoin);
+            const isValidLegacyPublicKey = addr.isValidLegacyPublicKey(networks.bitcoin);
 
-            expect(isValid).toBe(true);
+            expect(isValidLegacyPublicKey).toBe(true);
         });
 
         it('should validate address on testnet', () => {
@@ -937,9 +935,9 @@ describe('Address - Comprehensive Tests', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
             const wallet = mnemonic.derive(0);
-            const isValid = wallet.address.isValid(networks.testnet);
+            const isValidLegacyPublicKey = wallet.address.isValidLegacyPublicKey(networks.testnet);
 
-            expect(isValid).toBe(true);
+            expect(isValidLegacyPublicKey).toBe(true);
         });
     });