@btc-vision/transaction 1.7.7 → 1.7.10

package/build/transaction/builders/TransactionBuilder.js

@@ -4,6 +4,12 @@ import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+import { Features } 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);
 export const MINIMUM_AMOUNT_REWARD = 330n;
 export const MINIMUM_AMOUNT_CA = 297n;
@@ -112,6 +118,7 @@ export class TransactionBuilder extends TweakedTransaction {
             amount: this.estimatedFees,
             optionalOutputs: this.optionalOutputs,
             optionalInputs: this.optionalInputs,
+            mldsaSigner: null,
         };
     }
     setDestinationAddress(address) {
@@ -487,6 +494,76 @@ export class TransactionBuilder extends TweakedTransaction {
         }
         throw new Error('Output not found');
     }
+    generateLegacySignature() {
+        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();
+        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);
+    }
+    generateMLDSASignature() {
+        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);
+    }
+    generateMLDSALinkRequest(parameters, features) {
+        const mldsaSigner = this.mldsaSigner;
+        const legacySignature = this.generateLegacySignature();
+        let mldsaSignature = null;
+        if (parameters.revealMLDSAPublicKey) {
+            mldsaSignature = this.generateMLDSASignature();
+        }
+        const mldsaRequest = {
+            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);
+    }
     getTransactionOPNetFee() {
         const totalFee = this.priorityFee + this.gasSatFee;
         if (totalFee > TransactionBuilder.MINIMUM_DUST) {

package/build/transaction/interfaces/ITransactionParameters.d.ts

@@ -10,6 +10,8 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     readonly from?: string;
     readonly to?: string;
     readonly debugFees?: boolean;
+    readonly revealMLDSAPublicKey?: boolean;
+    readonly linkMLDSAPublicKeyToAddress?: boolean;
     utxos: UTXO[];
     nonWitnessUtxo?: Buffer;
     estimatedFees?: bigint;
@@ -22,6 +24,7 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     readonly feeRate: number;
     readonly priorityFee: bigint;
     readonly gasSatFee: bigint;
+    readonly compiledTargetScript?: Buffer | string;
 }
 export interface IFundingTransactionParameters extends ITransactionParameters {
     amount: bigint;

package/build/transaction/shared/P2TR_MS.js

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

package/build/transaction/shared/TweakedTransaction.d.ts

@@ -6,8 +6,10 @@ import { TapLeafScript } from '../interfaces/Tap.js';
 import { ChainId } from '../../network/ChainId.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 import { Buffer } from 'buffer';
+import { QuantumBIP32Interface } from '@btc-vision/bip32';
 export type SupportedTransactionVersion = 1 | 2 | 3;
 export interface ITweakedTransactionData {
+    readonly mldsaSigner: QuantumBIP32Interface | null;
     readonly signer: Signer | ECPairInterface | UnisatSigner;
     readonly network: Network;
     readonly chainId?: ChainId;
@@ -47,7 +49,11 @@ export declare abstract class TweakedTransaction extends Logger {
     protected noSignatures: boolean;
     protected unlockScript: Buffer[] | undefined;
     protected txVersion: SupportedTransactionVersion;
+    protected readonly _mldsaSigner: QuantumBIP32Interface | null;
+    protected readonly _hashedPublicKey: Buffer | null;
     protected constructor(data: ITweakedTransactionData);
+    protected get mldsaSigner(): QuantumBIP32Interface;
+    protected get hashedPublicKey(): Buffer;
     static readScriptWitnessToWitnessStack(buffer: Buffer): Buffer[];
     static preEstimateTaprootTransactionFees(feeRate: bigint, numInputs: bigint, numOutputs: bigint, numWitnessElements: bigint, witnessElementSize: bigint, emptyWitness: bigint, taprootControlWitnessSize?: bigint, taprootScriptSize?: bigint): bigint;
     protected static signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, sighashTypes: number[]): void;

package/build/transaction/shared/TweakedTransaction.js

@@ -5,6 +5,7 @@ import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../s
 import { TransactionBuilder } from '../builders/TransactionBuilder.js';
 import { Buffer } from 'buffer';
 import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+import { MessageSigner } from '../../keypair/MessageSigner.js';
 export var TransactionSequence;
 (function (TransactionSequence) {
     TransactionSequence[TransactionSequence["REPLACE_BY_FEE"] = 4294967293] = "REPLACE_BY_FEE";
@@ -34,6 +35,8 @@ export class TweakedTransaction extends Logger {
         this.ignoreSignatureErrors = false;
         this.noSignatures = false;
         this.txVersion = 2;
+        this._mldsaSigner = null;
+        this._hashedPublicKey = null;
         this.customFinalizerP2SH = (inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH) => {
             const inputDecoded = this.inputs[inputIndex];
             if (isP2SH && input.partialSig && inputDecoded && inputDecoded.redeemScript) {
@@ -78,6 +81,22 @@ export 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 mldsaSigner() {
+        if (!this._mldsaSigner) {
+            throw new Error('MLDSA Signer is not set');
+        }
+        return this._mldsaSigner;
+    }
+    get hashedPublicKey() {
+        if (!this._hashedPublicKey) {
+            throw new Error('Hashed public key is not set');
+        }
+        return this._hashedPublicKey;
     }
     static readScriptWitnessToWitnessStack(buffer) {
         let offset = 0;

package/build/utxo/OPNetLimitedProvider.d.ts

@@ -6,6 +6,7 @@ export interface WalletUTXOs {
     readonly confirmed: RawUTXOResponse[];
     readonly pending: RawUTXOResponse[];
     readonly spentTransactions: RawUTXOResponse[];
+    readonly raw: string[];
 }
 export declare class OPNetLimitedProvider {
     private readonly opnetAPIUrl;

package/build/utxo/OPNetLimitedProvider.js

@@ -24,6 +24,7 @@ export class OPNetLimitedProvider {
             throw new Error(`Failed to fetch UTXO data: ${resp.statusText}`);
         }
         const fetchedData = (await resp.json());
+        const rawTransactions = fetchedData.raw ?? [];
         const allUtxos = settings.usePendingUTXO
             ? [...fetchedData.confirmed, ...fetchedData.pending]
             : fetchedData.confirmed;
@@ -52,13 +53,21 @@ export class OPNetLimitedProvider {
             if (utxoValue <= 0n) {
                 continue;
             }
+            const rawIndex = utxo.raw;
+            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) {
                 break;
@@ -124,6 +133,7 @@ export class OPNetLimitedProvider {
             splitInputsInto,
             priorityFee: 0n,
             gasSatFee: 330n,
+            mldsaSigner: null,
         };
         const transactionFactory = new TransactionFactory();
         const fundingTx = await transactionFactory.createBTCTransfer(fundingTransactionParameters);

package/eslint.config.js

@@ -29,7 +29,8 @@ export default tseslint.config(
             '@typescript-eslint/no-duplicate-enum-values': 'off',
             'prefer-spread': 'off',
             '@typescript-eslint/no-empty-object-type': 'off',
-            '@typescript-eslint/prefer-literal-enum-member': 'off'
+            '@typescript-eslint/prefer-literal-enum-member': 'off',
+            '@typescript-eslint/related-getter-setter-pairs': 'off'
         },
     },
     {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.7.7",
+    "version": "1.7.10",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.7.7';
+export const version = '1.7.10';

package/src/chain/ChainData.ts

@@ -0,0 +1,32 @@
+import { Network, networks } from '@btc-vision/bitcoin';
+
+function objectEqual<T>(obj1: T, obj2: T): boolean {
+    return JSON.stringify(obj1) === JSON.stringify(obj2);
+}
+
+export function getChainIdHex(network: Network): string {
+    if (objectEqual(network, networks.bitcoin)) {
+        return '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f';
+    }
+
+    if (objectEqual(network, networks.testnet)) {
+        return '000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943';
+    }
+
+    if (objectEqual(network, networks.regtest)) {
+        return '0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206';
+    }
+
+    throw new Error('Unsupported network for chain ID retrieval');
+}
+
+export function getChainId(network: Network): Uint8Array {
+    return Uint8Array.from(Buffer.from(getChainIdHex(network), 'hex'));
+}
+
+export const BITCOIN_PROTOCOL_ID = Uint8Array.from(
+    Buffer.from(
+        'e784995a412d773988c4b8e333d7b39dfb3cabf118d0d645411a916ca2407939', // sha256("OP_NET")
+        'hex',
+    ),
+);

package/src/epoch/ChallengeSolution.ts

@@ -42,7 +42,7 @@ export class ChallengeSubmission implements IChallengeSubmission {
         data: RawChallengeSubmission,
         public readonly epochNumber: bigint,
     ) {
-        this.publicKey = Address.fromString(data.publicKey, data.classicPublicKey);
+        this.publicKey = Address.fromString(data.mldsaPublicKey, data.legacyPublicKey);
         this.solution = stringToBuffer(data.solution);
         this.graffiti = data.graffiti ? stringToBuffer(data.graffiti) : undefined;
         this.signature = stringToBuffer(data.signature);
@@ -76,7 +76,7 @@ export class ChallengeSolution implements IChallengeSolution {
 
     constructor(data: RawChallenge) {
         this.epochNumber = BigInt(data.epochNumber);
-        this.publicKey = Address.fromString(data.publicKey, data.classicPublicKey);
+        this.publicKey = Address.fromString(data.mldsaPublicKey, data.legacyPublicKey);
         this.solution = stringToBuffer(data.solution);
         this.salt = stringToBuffer(data.salt);
         this.graffiti = stringToBuffer(data.graffiti);
@@ -144,8 +144,8 @@ export class ChallengeSolution implements IChallengeSolution {
     public toRaw(): RawChallenge {
         return {
             epochNumber: this.epochNumber.toString(),
-            publicKey: this.publicKey.toHex(),
-            classicPublicKey: this.publicKey.tweakedToHex(),
+            mldsaPublicKey: this.publicKey.toHex(),
+            legacyPublicKey: this.publicKey.tweakedToHex(),
             solution: this.toHex(),
             salt: '0x' + this.salt.toString('hex'),
             graffiti: '0x' + this.graffiti.toString('hex'),

package/src/epoch/interfaces/IChallengeSolution.ts

@@ -31,8 +31,8 @@ export interface RawChallengeVerification {
 }
 
 export interface RawChallengeSubmission {
-    readonly classicPublicKey: string;
-    readonly publicKey: string;
+    readonly mldsaPublicKey: string;
+    readonly legacyPublicKey: string;
     readonly solution: string;
     readonly graffiti?: string;
     readonly signature: string;
@@ -47,8 +47,8 @@ export interface IChallengeSubmission {
 
 export interface RawChallenge {
     readonly epochNumber: string;
-    readonly classicPublicKey: string;
-    readonly publicKey: string;
+    readonly mldsaPublicKey: string;
+    readonly legacyPublicKey: string;
     readonly solution: string;
     readonly salt: string;
     readonly graffiti: string;

package/src/generators/Features.ts

@@ -1,9 +1,11 @@
 import { LoadedStorage } from '../transaction/interfaces/ITransactionParameters.js';
 import { ChallengeSubmission } from '../epoch/ChallengeSolution.js';
+import { MLDSARequestData } from './MLDSAData.js';
 
 export enum Features {
-    ACCESS_LIST = 1,
-    EPOCH_SUBMISSION = 2,
+    ACCESS_LIST = 0b1,
+    EPOCH_SUBMISSION = 0b10,
+    MLDSA_LINK_PUBKEY = 0b100,
 }
 
 export interface Feature<T extends Features> {
@@ -18,3 +20,7 @@ export interface AccessListFeature extends Feature<Features.ACCESS_LIST> {
 export interface EpochSubmissionFeature extends Feature<Features.EPOCH_SUBMISSION> {
     data: ChallengeSubmission;
 }
+
+export interface MLDSALinkRequest extends Feature<Features.MLDSA_LINK_PUBKEY> {
+    data: MLDSARequestData;
+}

package/src/generators/Generator.ts

@@ -1,6 +1,6 @@
 import { Network, networks, toXOnly } from '@btc-vision/bitcoin';
 import { BinaryWriter } from '../buffer/BinaryWriter.js';
-import { AccessListFeature, EpochSubmissionFeature, Feature, Features } from './Features.js';
+import { AccessListFeature, EpochSubmissionFeature, Feature, Features, MLDSALinkRequest, } from './Features.js';
 import { Address } from '../keypair/Address.js';
 import { Compressor } from '../bytecode/Compressor.js';
 
@@ -117,6 +117,11 @@ export abstract class Generator {
                     this.encodeChallengeSubmission(feature as EpochSubmissionFeature),
                 );
             }
+            case Features.MLDSA_LINK_PUBKEY: {
+                return this.splitBufferIntoChunks(
+                    this.encodeLinkRequest(feature as MLDSALinkRequest),
+                );
+            }
             default:
                 throw new Error(`Unknown feature type: ${feature.opcode}`);
         }
@@ -154,7 +159,7 @@ export abstract class Generator {
         }
 
         const writer = new BinaryWriter();
-        writer.writeBytes(feature.data.publicKey.originalPublicKeyBuffer());
+        writer.writeBytes(feature.data.publicKey.toBuffer());
         writer.writeBytes(feature.data.solution);
 
         if (feature.data.graffiti) {
@@ -163,4 +168,32 @@ export abstract class Generator {
 
         return Buffer.from(writer.getBuffer());
     }
+
+    private encodeLinkRequest(feature: MLDSALinkRequest): Buffer {
+        const data = feature.data;
+
+        const writer = new BinaryWriter();
+        writer.writeU8(data.level);
+        writer.writeBytes(data.hashedPublicKey);
+        writer.writeBoolean(data.verifyRequest);
+
+        if (data.verifyRequest) {
+            if (!data.publicKey || !data.mldsaSignature) {
+                throw new Error(
+                    'MLDSA public key and signature required when verifyRequest is true',
+                );
+            }
+
+            writer.writeBytes(data.publicKey);
+            writer.writeBytes(data.mldsaSignature);
+        }
+
+        if (!data.legacySignature || data.legacySignature.length !== 64) {
+            throw new Error('Legacy signature must be exactly 64 bytes');
+        }
+
+        writer.writeBytes(data.legacySignature);
+
+        return Buffer.from(writer.getBuffer());
+    }
 }

package/src/generators/MLDSAData.ts

@@ -0,0 +1,30 @@
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
+
+export enum MLDSAPublicKeyMetadata {
+    MLDSA44 = 1312,
+    MLDSA65 = 1952,
+    MLDSA87 = 2592,
+}
+
+export interface MLDSARequestData {
+    readonly verifyRequest: boolean;
+    readonly publicKey: Uint8Array | Buffer | null;
+    readonly hashedPublicKey: Uint8Array | Buffer;
+    readonly level: MLDSASecurityLevel;
+
+    readonly mldsaSignature: Uint8Array | Buffer | null;
+    readonly legacySignature: Uint8Array | Buffer;
+}
+
+export function getLevelFromPublicKeyLength(length: number): MLDSASecurityLevel {
+    switch (length) {
+        case MLDSAPublicKeyMetadata.MLDSA44 as number:
+            return MLDSASecurityLevel.LEVEL2;
+        case MLDSAPublicKeyMetadata.MLDSA65 as number:
+            return MLDSASecurityLevel.LEVEL3;
+        case MLDSAPublicKeyMetadata.MLDSA87 as number:
+            return MLDSASecurityLevel.LEVEL5;
+        default:
+            throw new Error(`Invalid MLDSA public key length: ${length}`);
+    }
+}

package/src/generators/builders/CalldataGenerator.ts

@@ -90,7 +90,7 @@ export class CalldataGenerator extends Generator {
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
-            challenge.publicKey.originalPublicKeyBuffer(),
+            challenge.publicKey.toBuffer(),
             opcodes.OP_TOALTSTACK,
 
             challenge.solution,

package/src/generators/builders/DeploymentGenerator.ts

@@ -41,6 +41,7 @@ export class DeploymentGenerator extends Generator {
             calldata,
             features,
         );
+
         const compiled = script.compile(asm);
 
         /**
@@ -85,7 +86,7 @@ export class DeploymentGenerator extends Generator {
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
-            challenge.publicKey.originalPublicKeyBuffer(),
+            challenge.publicKey.toBuffer(),
             opcodes.OP_TOALTSTACK,
 
             challenge.solution,

package/src/generators/builders/LegacyCalldataGenerator.ts

@@ -7,6 +7,7 @@ import { Feature, Features } from '../Features.js';
 
 /**
  * Class to generate bitcoin script for interaction transactions
+ * @deprecated
  */
 export class LegacyCalldataGenerator extends Generator {
     constructor(senderPubKey: Buffer, network: Network = networks.bitcoin) {

package/src/generators/builders/P2WDAGenerator.ts

@@ -4,6 +4,10 @@ import { Feature, Features } from '../Features.js';
 import { Generator } from '../Generator.js';
 import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 
+/**
+ * @category Generators
+ * @remarks Not fully implemented yet
+ */
 export class P2WDAGenerator extends Generator {
     private static readonly P2WDA_VERSION = 0x01;
 
@@ -90,7 +94,7 @@ export class P2WDAGenerator extends Generator {
         writer.writeBytes(contractSecret);
 
         // Challenge components for epoch rewards
-        writer.writeBytes(challenge.publicKey.originalPublicKeyBuffer());
+        writer.writeBytes(challenge.publicKey.toBuffer());
         writer.writeBytes(challenge.solution);
 
         // Calldata with length prefix