@btc-vision/transaction 1.7.6 → 1.7.10

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;

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.6",
+    "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.1';
+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/deterministic/AddressMap.ts

@@ -1,11 +1,11 @@
 import { Address } from '../keypair/Address.js';
-import { Map } from './Map.js';
+import { FastMap } from './FastMap.js';
 
 export class AddressMap<V> {
-    private items: Map<bigint, V>;
+    private items: FastMap<bigint, V>;
 
     constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null) {
-        this.items = new Map();
+        this.items = new FastMap();
 
         if (iterable) {
             for (const [key, value] of iterable) {

package/src/deterministic/DeterministicMap.ts

@@ -1,11 +1,11 @@
-import { Map } from './Map.js';
+import { FastMap, PropertyExtendedKey } from './FastMap.js';
 
-export class DeterministicMap<K, V> {
-    private map: Map<K, V>;
+export class DeterministicMap<K extends PropertyExtendedKey, V> {
+    private map: FastMap<K, V>;
     #keys: K[];
 
     constructor(private compareFn: (a: K, b: K) => number) {
-        this.map = new Map<K, V>();
+        this.map = new FastMap<K, V>();
         this.#keys = [];
     }
 
@@ -13,8 +13,8 @@ export class DeterministicMap<K, V> {
         return this.map.size;
     }
 
-    public static fromMap<K, V>(
-        map: Map<K, V>,
+    public static fromMap<K extends PropertyExtendedKey, V>(
+        map: FastMap<K, V>,
         compareFn: (a: K, b: K) => number,
     ): DeterministicMap<K, V> {
         const deterministicMap = new DeterministicMap<K, V>(compareFn);
@@ -29,6 +29,7 @@ export class DeterministicMap<K, V> {
             // Binary search for insertion position
             let left = 0,
                 right = this.#keys.length;
+
             while (left < right) {
                 const mid = Math.floor((left + right) / 2);
                 if (this.compareFn(this.#keys[mid], key) < 0) {
@@ -39,6 +40,7 @@ export class DeterministicMap<K, V> {
             }
             this.#keys.splice(left, 0, key);
         }
+
         this.map.set(key, value);
     }
 
@@ -78,6 +80,7 @@ export class DeterministicMap<K, V> {
             // Binary search to find the key's index
             let left = 0,
                 right = this.#keys.length - 1;
+
             while (left <= right) {
                 const mid = Math.floor((left + right) / 2);
                 const cmp = this.compareFn(this.#keys[mid], key);

package/src/deterministic/{Map.ts → FastMap.ts}

@@ -1,9 +1,21 @@
-export class Map<K, V> {
+export type PropertyExtendedKey = PropertyKey | bigint;
+
+/**
+ * Like Record, but supports bigint keys (which JS auto-converts to strings).
+ * Reflects actual JavaScript behavior where obj[123n] becomes obj["123"].
+ */
+export type FastRecord<V> = {
+    [key: string]: V;
+};
+
+export type IndexKey = string | number;
+
+export class FastMap<K extends PropertyExtendedKey, V> {
     protected _keys: K[] = [];
-    protected _values: Record<string, V> = {};
+    protected _values: FastRecord<V> = {};
 
-    constructor(iterable?: ReadonlyArray<readonly [K, V]> | null | Map<K, V>) {
-        if (iterable instanceof Map) {
+    constructor(iterable?: ReadonlyArray<readonly [K, V]> | null | FastMap<K, V>) {
+        if (iterable instanceof FastMap) {
             this.setAll(iterable);
         } else {
             if (iterable) {
@@ -18,13 +30,12 @@ export class Map<K, V> {
         return this._keys.length;
     }
 
-    public setAll(map: Map<K, V>): void {
-        for (const [key, value] of map) {
-            this.set(key, value);
-        }
+    public setAll(map: FastMap<K, V>): void {
+        this._keys = [...map._keys];
+        this._values = { ...map._values };
     }
 
-    public addAll(map: Map<K, V>): void {
+    public addAll(map: FastMap<K, V>): void {
         for (const [key, value] of map.entries()) {
             this.set(key, value);
         }
@@ -36,52 +47,58 @@ export class Map<K, V> {
 
     public *values(): IterableIterator<V> {
         for (const key of this._keys) {
-            yield this._values[this.keyToString(key)];
+            yield this._values[key as IndexKey];
         }
     }
 
     public *entries(): IterableIterator<[K, V]> {
         for (const key of this._keys) {
-            yield [key, this._values[this.keyToString(key)]];
+            yield [key, this._values[key as IndexKey]];
         }
     }
 
-    public set(key: K, value: V): void {
-        const keyStr = this.keyToString(key);
+    public set(key: K, value: V): this {
         if (!this.has(key)) {
             this._keys.push(key);
         }
 
-        this._values[keyStr] = value;
+        this._values[key as IndexKey] = value;
+
+        return this;
     }
 
     public indexOf(key: K): number {
+        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.');
     }
 
     public get(key: K): V | undefined {
-        return this._values[this.keyToString(key)];
+        return this._values[key as IndexKey];
     }
 
     public has(key: K): boolean {
-        return Object.prototype.hasOwnProperty.call(this._values, this.keyToString(key));
+        return Object.prototype.hasOwnProperty.call(this._values, key as IndexKey);
     }
 
     public delete(key: K): boolean {
-        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);
+
         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        delete this._values[keyStr];
+        delete this._values[key as IndexKey];
         return true;
     }
 
@@ -90,22 +107,18 @@ export class Map<K, V> {
         this._values = {};
     }
 
-    *[Symbol.iterator](): IterableIterator<[K, V]> {
+    public forEach(
+        callback: (value: V, key: K, map: FastMap<K, V>) => void,
+        thisArg?: unknown,
+    ): void {
         for (const key of this._keys) {
-            yield [key, this._values[this.keyToString(key)]];
+            callback.call(thisArg, this._values[key as IndexKey], key, this);
         }
     }
 
-    private keyToString(key: K): string {
-        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](): IterableIterator<[K, V]> {
+        for (const key of this._keys) {
+            yield [key, this._values[key as IndexKey]];
         }
-        return String(key);
     }
 }

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;
+}