@btc-vision/transaction 1.7.6 → 1.7.10

package/browser/{src/keypair → keypair}/Address.d.ts

@@ -1,19 +1,25 @@
 import { Network } from '@btc-vision/bitcoin';
 import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
 export declare class Address extends Uint8Array {
     #private;
-    private classicPublicKey;
+    private legacyPublicKey;
     constructor(mldsaPublicKey?: ArrayLike<number>, publicKeyOrTweak?: ArrayLike<number>);
+    get mldsaLevel(): MLDSASecurityLevel | undefined;
+    set mldsaLevel(level: MLDSASecurityLevel);
+    get originalMDLSAPublicKey(): Uint8Array | undefined;
+    set originalMDLSAPublicKey(key: Buffer | Uint8Array);
     get originalPublicKey(): Uint8Array | undefined;
     get mldsaPublicKey(): Uint8Array | undefined;
     private get keyPair();
     static dead(): Address;
-    static fromString(mldsaPublicKey: string, classicPublicKey?: string): Address;
+    static fromString(mldsaPublicKey: string, legacyPublicKey?: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;
     static fromBigInt(value: bigint): Address;
     static fromUint64Array(w0: bigint, w1: bigint, w2: bigint, w3: bigint): Address;
     toUint64Array(): [bigint, bigint, bigint, bigint];
+    isDead(): boolean;
     toHex(): string;
     tweakedToHex(): string;
     toBuffer(): Buffer;
@@ -28,7 +34,7 @@ export declare class Address extends Uint8Array {
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;
     set(mldsaPublicKey: ArrayLike<number>): void;
-    isValid(network: Network): boolean;
+    isValidLegacyPublicKey(network: Network): boolean;
     p2pk(): string;
     p2wpkh(network: Network): string;
     p2pkh(network: Network): string;

package/browser/{src/keypair → 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/browser/{src/opnet.d.ts → 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';
@@ -75,7 +76,7 @@ export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
 export * from './keypair/Secp256k1PointDeriver.js';
 export * from './transaction/ContractAddress.js';
-export * from './deterministic/Map.js';
+export * from './deterministic/FastMap.js';
 export * from './deterministic/CustomMap.js';
 declare global {
     interface Window {

package/browser/{src/transaction → 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/browser/transaction/browser/types/OPWallet.d.ts

@@ -0,0 +1,6 @@
+import { Unisat } from './Unisat.js';
+import { Web3Provider } from '../Web3Provider.js';
+export interface OPWallet extends Unisat {
+    web3: Web3Provider;
+}
+export declare function isOPWallet(wallet: unknown): wallet is OPWallet;

package/browser/{src/transaction → 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/browser/{src/transaction → 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/browser/{src/transaction → 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;

package/browser/{src/transaction → 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/browser/{src/transaction → 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/browser/{src/utxo → 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/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.1";
+export declare const version = "1.7.10";

package/build/_version.js

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

package/build/chain/ChainData.d.ts

@@ -0,0 +1,4 @@
+import { Network } from '@btc-vision/bitcoin';
+export declare function getChainIdHex(network: Network): string;
+export declare function getChainId(network: Network): Uint8Array;
+export declare const BITCOIN_PROTOCOL_ID: Uint8Array<ArrayBuffer>;

package/build/chain/ChainData.js

@@ -0,0 +1,20 @@
+import { networks } from '@btc-vision/bitcoin';
+function objectEqual(obj1, obj2) {
+    return JSON.stringify(obj1) === JSON.stringify(obj2);
+}
+export function getChainIdHex(network) {
+    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) {
+    return Uint8Array.from(Buffer.from(getChainIdHex(network), 'hex'));
+}
+export const BITCOIN_PROTOCOL_ID = Uint8Array.from(Buffer.from('e784995a412d773988c4b8e333d7b39dfb3cabf118d0d645411a916ca2407939', 'hex'));

package/build/deterministic/AddressMap.js

@@ -1,8 +1,8 @@
 import { Address } from '../keypair/Address.js';
-import { Map } from './Map.js';
+import { FastMap } from './FastMap.js';
 export class AddressMap {
     constructor(iterable) {
-        this.items = new Map();
+        this.items = new FastMap();
         if (iterable) {
             for (const [key, value] of iterable) {
                 this.set(key, value);

package/build/deterministic/DeterministicMap.d.ts

@@ -1,11 +1,11 @@
-import { Map } from './Map.js';
-export declare class DeterministicMap<K, V> {
+import { FastMap, PropertyExtendedKey } from './FastMap.js';
+export declare class DeterministicMap<K extends PropertyExtendedKey, V> {
     #private;
     private compareFn;
     private map;
     constructor(compareFn: (a: K, b: K) => number);
     get size(): number;
-    static fromMap<K, V>(map: Map<K, V>, compareFn: (a: K, b: K) => number): DeterministicMap<K, V>;
+    static fromMap<K extends PropertyExtendedKey, V>(map: FastMap<K, V>, compareFn: (a: K, b: K) => number): DeterministicMap<K, V>;
     set(key: K, value: V): void;
     get(key: K): V | undefined;
     entries(): IterableIterator<[K, V]>;

package/build/deterministic/DeterministicMap.js

@@ -10,12 +10,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _DeterministicMap_keys;
-import { Map } from './Map.js';
+import { FastMap } from './FastMap.js';
 export class DeterministicMap {
     constructor(compareFn) {
         this.compareFn = compareFn;
         _DeterministicMap_keys.set(this, void 0);
-        this.map = new Map();
+        this.map = new FastMap();
         __classPrivateFieldSet(this, _DeterministicMap_keys, [], "f");
     }
     get size() {

package/build/deterministic/FastMap.d.ts

@@ -0,0 +1,24 @@
+export type PropertyExtendedKey = PropertyKey | bigint;
+export type FastRecord<V> = {
+    [key: string]: V;
+};
+export type IndexKey = string | number;
+export declare class FastMap<K extends PropertyExtendedKey, V> {
+    protected _keys: K[];
+    protected _values: FastRecord<V>;
+    constructor(iterable?: ReadonlyArray<readonly [K, V]> | null | FastMap<K, V>);
+    get size(): number;
+    setAll(map: FastMap<K, V>): void;
+    addAll(map: FastMap<K, V>): void;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    set(key: K, value: V): this;
+    indexOf(key: K): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    forEach(callback: (value: V, key: K, map: FastMap<K, V>) => void, thisArg?: unknown): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/build/deterministic/{Map.js → FastMap.js}

@@ -1,8 +1,8 @@
-export class Map {
+export class FastMap {
     constructor(iterable) {
         this._keys = [];
         this._values = {};
-        if (iterable instanceof Map) {
+        if (iterable instanceof FastMap) {
             this.setAll(iterable);
         }
         else {
@@ -17,9 +17,8 @@ export class Map {
         return this._keys.length;
     }
     setAll(map) {
-        for (const [key, value] of map) {
-            this.set(key, value);
-        }
+        this._keys = [...map._keys];
+        this._values = { ...map._values };
     }
     addAll(map) {
         for (const [key, value] of map.entries()) {
@@ -31,64 +30,59 @@ export class Map {
     }
     *values() {
         for (const key of this._keys) {
-            yield this._values[this.keyToString(key)];
+            yield this._values[key];
         }
     }
     *entries() {
         for (const key of this._keys) {
-            yield [key, this._values[this.keyToString(key)]];
+            yield [key, this._values[key]];
         }
     }
     set(key, value) {
-        const keyStr = this.keyToString(key);
         if (!this.has(key)) {
             this._keys.push(key);
         }
-        this._values[keyStr] = value;
+        this._values[key] = value;
+        return this;
     }
     indexOf(key) {
+        if (!this.has(key)) {
+            return -1;
+        }
         for (let i = 0; i < this._keys.length; i++) {
             if (this._keys[i] === key) {
                 return i;
             }
         }
-        return -1;
+        throw new Error('Key not found, this should not happen.');
     }
     get(key) {
-        return this._values[this.keyToString(key)];
+        return this._values[key];
     }
     has(key) {
-        return Object.prototype.hasOwnProperty.call(this._values, this.keyToString(key));
+        return Object.prototype.hasOwnProperty.call(this._values, key);
     }
     delete(key) {
-        const index = this.indexOf(key);
-        if (index === -1) {
+        if (!this.has(key)) {
             return false;
         }
-        const keyStr = this.keyToString(key);
+        const index = this.indexOf(key);
         this._keys.splice(index, 1);
-        delete this._values[keyStr];
+        delete this._values[key];
         return true;
     }
     clear() {
         this._keys = [];
         this._values = {};
     }
-    *[Symbol.iterator]() {
+    forEach(callback, thisArg) {
         for (const key of this._keys) {
-            yield [key, this._values[this.keyToString(key)]];
+            callback.call(thisArg, this._values[key], key, this);
         }
     }
-    keyToString(key) {
-        if (typeof key === 'string') {
-            return key;
-        }
-        if (typeof key === 'number' || typeof key === 'boolean') {
-            return String(key);
-        }
-        if (typeof key === 'object' && key !== null) {
-            return JSON.stringify(key);
+    *[Symbol.iterator]() {
+        for (const key of this._keys) {
+            yield [key, this._values[key]];
         }
-        return String(key);
     }
 }

package/build/epoch/ChallengeSolution.js

@@ -17,7 +17,7 @@ export class ChallengeVerification {
 export class ChallengeSubmission {
     constructor(data, epochNumber) {
         this.epochNumber = epochNumber;
-        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);
@@ -37,7 +37,7 @@ export class ChallengeSubmission {
 export class ChallengeSolution {
     constructor(data) {
         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);
@@ -77,8 +77,8 @@ export class ChallengeSolution {
     toRaw() {
         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/build/epoch/interfaces/IChallengeSolution.d.ts

@@ -27,8 +27,8 @@ export interface RawChallengeVerification {
     readonly proofs: readonly string[];
 }
 export interface RawChallengeSubmission {
-    readonly classicPublicKey: string;
-    readonly publicKey: string;
+    readonly mldsaPublicKey: string;
+    readonly legacyPublicKey: string;
     readonly solution: string;
     readonly graffiti?: string;
     readonly signature: string;
@@ -41,8 +41,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/build/generators/Features.d.ts

@@ -1,8 +1,10 @@
 import { LoadedStorage } from '../transaction/interfaces/ITransactionParameters.js';
 import { ChallengeSubmission } from '../epoch/ChallengeSolution.js';
+import { MLDSARequestData } from './MLDSAData.js';
 export declare enum Features {
     ACCESS_LIST = 1,
-    EPOCH_SUBMISSION = 2
+    EPOCH_SUBMISSION = 2,
+    MLDSA_LINK_PUBKEY = 4
 }
 export interface Feature<T extends Features> {
     opcode: T;
@@ -14,3 +16,6 @@ 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/build/generators/Features.js

@@ -2,4 +2,5 @@ export var Features;
 (function (Features) {
     Features[Features["ACCESS_LIST"] = 1] = "ACCESS_LIST";
     Features[Features["EPOCH_SUBMISSION"] = 2] = "EPOCH_SUBMISSION";
+    Features[Features["MLDSA_LINK_PUBKEY"] = 4] = "MLDSA_LINK_PUBKEY";
 })(Features || (Features = {}));

package/build/generators/Generator.d.ts

@@ -15,4 +15,5 @@ export declare abstract class Generator {
     protected encodeFeature(feature: Feature<Features>): Buffer[][];
     private encodeAccessListFeature;
     private encodeChallengeSubmission;
+    private encodeLinkRequest;
 }

package/build/generators/Generator.js

@@ -1,6 +1,6 @@
 import { networks, toXOnly } from '@btc-vision/bitcoin';
 import { BinaryWriter } from '../buffer/BinaryWriter.js';
-import { Features } from './Features.js';
+import { Features, } from './Features.js';
 import { Address } from '../keypair/Address.js';
 import { Compressor } from '../bytecode/Compressor.js';
 export class Generator {
@@ -46,6 +46,9 @@ export class Generator {
             case Features.EPOCH_SUBMISSION: {
                 return this.splitBufferIntoChunks(this.encodeChallengeSubmission(feature));
             }
+            case Features.MLDSA_LINK_PUBKEY: {
+                return this.splitBufferIntoChunks(this.encodeLinkRequest(feature));
+            }
             default:
                 throw new Error(`Unknown feature type: ${feature.opcode}`);
         }
@@ -73,13 +76,32 @@ export class Generator {
             throw new Error('Invalid signature in challenge submission feature');
         }
         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) {
             writer.writeBytesWithLength(feature.data.graffiti);
         }
         return Buffer.from(writer.getBuffer());
     }
+    encodeLinkRequest(feature) {
+        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());
+    }
 }
 Generator.DATA_CHUNK_SIZE = 512;
 Generator.MAGIC = Buffer.from('op', 'utf-8');

package/build/generators/MLDSAData.d.ts

@@ -0,0 +1,15 @@
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
+export declare 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 declare function getLevelFromPublicKeyLength(length: number): MLDSASecurityLevel;

package/build/generators/MLDSAData.js

@@ -0,0 +1,19 @@
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
+export var MLDSAPublicKeyMetadata;
+(function (MLDSAPublicKeyMetadata) {
+    MLDSAPublicKeyMetadata[MLDSAPublicKeyMetadata["MLDSA44"] = 1312] = "MLDSA44";
+    MLDSAPublicKeyMetadata[MLDSAPublicKeyMetadata["MLDSA65"] = 1952] = "MLDSA65";
+    MLDSAPublicKeyMetadata[MLDSAPublicKeyMetadata["MLDSA87"] = 2592] = "MLDSA87";
+})(MLDSAPublicKeyMetadata || (MLDSAPublicKeyMetadata = {}));
+export function getLevelFromPublicKeyLength(length) {
+    switch (length) {
+        case MLDSAPublicKeyMetadata.MLDSA44:
+            return MLDSASecurityLevel.LEVEL2;
+        case MLDSAPublicKeyMetadata.MLDSA65:
+            return MLDSASecurityLevel.LEVEL3;
+        case MLDSAPublicKeyMetadata.MLDSA87:
+            return MLDSASecurityLevel.LEVEL5;
+        default:
+            throw new Error(`Invalid MLDSA public key length: ${length}`);
+    }
+}

package/build/generators/builders/CalldataGenerator.js

@@ -41,7 +41,7 @@ export class CalldataGenerator extends Generator {
         let compiledData = [
             this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
-            challenge.publicKey.originalPublicKeyBuffer(),
+            challenge.publicKey.toBuffer(),
             opcodes.OP_TOALTSTACK,
             challenge.solution,
             opcodes.OP_TOALTSTACK,

package/build/generators/builders/DeploymentGenerator.js

@@ -33,7 +33,7 @@ export class DeploymentGenerator extends Generator {
         const compiledData = [
             this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
-            challenge.publicKey.originalPublicKeyBuffer(),
+            challenge.publicKey.toBuffer(),
             opcodes.OP_TOALTSTACK,
             challenge.solution,
             opcodes.OP_TOALTSTACK,

package/build/generators/builders/P2WDAGenerator.js

@@ -25,7 +25,7 @@ export class P2WDAGenerator extends Generator {
         writer.writeU8(P2WDAGenerator.P2WDA_VERSION);
         writer.writeBytes(this.getHeader(maxPriority, features.map((f) => f.opcode)));
         writer.writeBytes(contractSecret);
-        writer.writeBytes(challenge.publicKey.originalPublicKeyBuffer());
+        writer.writeBytes(challenge.publicKey.toBuffer());
         writer.writeBytes(challenge.solution);
         writer.writeU32(calldata.length);
         writer.writeBytes(calldata);