@btc-vision/transaction 1.7.7 → 1.7.11

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';

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.7";
+export declare const version = "1.7.11";

package/build/_version.js

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

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

package/build/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;