@btc-vision/transaction 1.7.6 → 1.7.10

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

package/src/keypair/Address.ts

@@ -9,6 +9,7 @@ import { TimeLockGenerator } from '../transaction/mineable/TimelockGenerator.js'
 import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 import { P2WDADetector } from '../p2wda/P2WDADetector.js';
 import { sha256 } from '@noble/hashes/sha2';
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
 
 /**
  * Objects of type "Address" represent hashed ML-DSA (quantum) public keys (using SHA256 of quantum keys) and maintain classical public keys separately.
@@ -32,8 +33,10 @@ export class Address extends Uint8Array {
     #mldsaPublicKey: Uint8Array | undefined;
     #cachedBigInt: bigint | undefined;
     #cachedUint64Array: [bigint, bigint, bigint, bigint] | undefined;
+    #originalMDLSAPublicKey: Uint8Array | undefined;
+    #mldsaLevel: MLDSASecurityLevel | undefined;
 
-    private classicPublicKey: Uint8Array | undefined;
+    private legacyPublicKey: Uint8Array | undefined;
 
     public constructor(mldsaPublicKey?: ArrayLike<number>, publicKeyOrTweak?: ArrayLike<number>) {
         super(ADDRESS_BYTE_LENGTH);
@@ -43,13 +46,29 @@ export class Address extends Uint8Array {
         }
 
         if (publicKeyOrTweak) {
-            this.classicPublicKey = new Uint8Array(publicKeyOrTweak.length);
-            this.classicPublicKey.set(publicKeyOrTweak);
+            this.legacyPublicKey = new Uint8Array(publicKeyOrTweak.length);
+            this.legacyPublicKey.set(publicKeyOrTweak);
         }
 
         this.set(mldsaPublicKey);
     }
 
+    public get mldsaLevel(): MLDSASecurityLevel | undefined {
+        return this.#mldsaLevel;
+    }
+
+    public set mldsaLevel(level: MLDSASecurityLevel) {
+        this.#mldsaLevel = level;
+    }
+
+    public get originalMDLSAPublicKey(): Uint8Array | undefined {
+        return this.#originalMDLSAPublicKey;
+    }
+
+    public set originalMDLSAPublicKey(key: Buffer | Uint8Array) {
+        this.#originalMDLSAPublicKey = new Uint8Array(key);
+    }
+
     /**
      * If available, this will return the original public key associated with the address.
      * @returns {Uint8Array} The original public key used to create the address.
@@ -68,7 +87,7 @@ export class Address extends Uint8Array {
      */
     private get keyPair(): ECPairInterface {
         if (!this.#keyPair) {
-            throw new Error('Classical public key not set for address');
+            throw new Error('Legacy public key not set for address');
         }
 
         return this.#keyPair;
@@ -84,10 +103,10 @@ export class Address extends Uint8Array {
     /**
      * Create an address from a hex string
      * @param {string} mldsaPublicKey The ml-dsa public key in hex format
-     * @param {string} classicPublicKey The classical public key in hex format
+     * @param {string} legacyPublicKey The classical public key in hex format
      * @returns {Address} The address
      */
-    public static fromString(mldsaPublicKey: string, classicPublicKey?: string): Address {
+    public static fromString(mldsaPublicKey: string, legacyPublicKey?: string): Address {
         if (!mldsaPublicKey) {
             throw new Error('Invalid public key');
         }
@@ -103,18 +122,18 @@ export class Address extends Uint8Array {
         }
 
         let classicBuffer: Buffer | undefined;
-        if (classicPublicKey) {
-            if (classicPublicKey.startsWith('0x')) {
-                classicPublicKey = classicPublicKey.slice(2);
+        if (legacyPublicKey) {
+            if (legacyPublicKey.startsWith('0x')) {
+                legacyPublicKey = legacyPublicKey.slice(2);
             }
 
-            if (!BitcoinUtils.isValidHex(classicPublicKey)) {
+            if (!BitcoinUtils.isValidHex(legacyPublicKey)) {
                 throw new Error(
                     'You must only pass classical public keys in hexadecimal format. If you have an address such as bc1q... you must convert it to a public key first. Please refer to await provider.getPublicKeyInfo("bc1q..."). If the public key associated with the address is not found, you must force the user to enter the destination public key. It looks like: 0x020373626d317ae8788ce3280b491068610d840c23ecb64c14075bbb9f670af52c.',
                 );
             }
 
-            classicBuffer = Buffer.from(classicPublicKey, 'hex');
+            classicBuffer = Buffer.from(legacyPublicKey, 'hex');
         }
 
         return new Address(Buffer.from(mldsaPublicKey, 'hex'), classicBuffer);
@@ -245,6 +264,20 @@ export class Address extends Uint8Array {
         return this.#cachedUint64Array;
     }
 
+    /**
+     * Check if the address is the dead address
+     * @returns {boolean}
+     */
+    public isDead(): boolean {
+        for (let i = 0; i < ADDRESS_BYTE_LENGTH; i++) {
+            if (this[i] !== 0) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Converts the address to a hex string
      * @returns {string} The hex string
@@ -258,11 +291,11 @@ export class Address extends Uint8Array {
      * @returns {string} The hex string
      */
     public tweakedToHex(): string {
-        if (!this.classicPublicKey) {
-            throw new Error('Classical public key not set');
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
         }
 
-        return '0x' + Buffer.from(this.classicPublicKey).toString('hex');
+        return '0x' + Buffer.from(this.legacyPublicKey).toString('hex');
     }
 
     /**
@@ -278,16 +311,16 @@ export class Address extends Uint8Array {
      * @returns {Buffer} The buffer
      */
     public tweakedPublicKeyToBuffer(): Buffer {
-        if (!this.classicPublicKey) {
-            throw new Error('Classical public key not set');
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
         }
 
-        return Buffer.from(this.classicPublicKey);
+        return Buffer.from(this.legacyPublicKey);
     }
 
     public toUncompressedHex(): string {
         if (!this.#uncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return '0x' + this.#uncompressed.uncompressed.toString('hex');
@@ -295,7 +328,7 @@ export class Address extends Uint8Array {
 
     public toUncompressedBuffer(): Buffer {
         if (!this.#uncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return this.#uncompressed.uncompressed;
@@ -303,7 +336,7 @@ export class Address extends Uint8Array {
 
     public toHybridPublicKeyHex(): string {
         if (!this.#uncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return '0x' + this.#uncompressed.hybrid.toString('hex');
@@ -311,7 +344,7 @@ export class Address extends Uint8Array {
 
     public toHybridPublicKeyBuffer(): Buffer {
         if (!this.#uncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return this.#uncompressed.hybrid;
@@ -319,7 +352,7 @@ export class Address extends Uint8Array {
 
     public originalPublicKeyBuffer(): Buffer {
         if (!this.#originalPublicKey) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return Buffer.from(this.#originalPublicKey);
@@ -421,19 +454,19 @@ export class Address extends Uint8Array {
      * @returns {void}
      */
     public override set(mldsaPublicKey: ArrayLike<number>): void {
-        if (this.classicPublicKey) {
+        if (this.legacyPublicKey) {
             const validLengths = [ADDRESS_BYTE_LENGTH, 33, 65];
-            if (!validLengths.includes(this.classicPublicKey.length)) {
-                throw new Error(`Invalid public key length ${this.classicPublicKey.length}`);
+            if (!validLengths.includes(this.legacyPublicKey.length)) {
+                throw new Error(`Invalid public key length ${this.legacyPublicKey.length}`);
             }
 
-            if (this.classicPublicKey.length === ADDRESS_BYTE_LENGTH) {
+            if (this.legacyPublicKey.length === ADDRESS_BYTE_LENGTH) {
                 const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
-                buf.set(this.classicPublicKey);
+                buf.set(this.legacyPublicKey);
 
                 this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(buf);
             } else {
-                this.autoFormat(this.classicPublicKey);
+                this.autoFormat(this.legacyPublicKey);
             }
         }
 
@@ -475,8 +508,15 @@ export class Address extends Uint8Array {
      * @param {Network} network The network
      * @returns {boolean} If the public key is valid
      */
-    public isValid(network: Network): boolean {
-        return AddressVerificator.isValidPublicKey(Buffer.from(this).toString('hex'), network);
+    public isValidLegacyPublicKey(network: Network): boolean {
+        if (!this.legacyPublicKey) {
+            throw new Error(`Legacy key not set.`);
+        }
+
+        return AddressVerificator.isValidPublicKey(
+            Buffer.from(this.legacyPublicKey).toString('hex'),
+            network,
+        );
     }
 
     /**
@@ -529,8 +569,8 @@ export class Address extends Uint8Array {
      * @param {Network} network The network
      */
     public p2tr(network: Network): string {
-        if (!this.classicPublicKey) {
-            throw new Error('Classical public key not set');
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
         }
 
         if (this.#p2tr && this.#network === network) {
@@ -538,7 +578,7 @@ export class Address extends Uint8Array {
         }
 
         const p2trAddy: string | undefined = EcKeyPair.tweakedPubKeyBufferToAddress(
-            this.classicPublicKey,
+            this.legacyPublicKey,
             network,
         );
 
@@ -549,7 +589,7 @@ export class Address extends Uint8Array {
             return p2trAddy;
         }
 
-        throw new Error('Classical public key not set');
+        throw new Error('Legacy public key not set');
     }
 
     /**
@@ -665,7 +705,7 @@ export class Address extends Uint8Array {
 
     public toTweakedHybridPublicKeyHex(): string {
         if (!this.#tweakedUncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return '0x' + this.#tweakedUncompressed.toString('hex');
@@ -673,7 +713,7 @@ export class Address extends Uint8Array {
 
     public toTweakedHybridPublicKeyBuffer(): Buffer {
         if (!this.#tweakedUncompressed) {
-            throw new Error('Classical public key not set');
+            throw new Error('Legacy public key not set');
         }
 
         return this.#tweakedUncompressed;
@@ -699,7 +739,7 @@ export class Address extends Uint8Array {
 
         this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(tweakedBytes);
 
-        this.classicPublicKey = new Uint8Array(ADDRESS_BYTE_LENGTH);
-        this.classicPublicKey.set(tweakedBytes);
+        this.legacyPublicKey = new Uint8Array(ADDRESS_BYTE_LENGTH);
+        this.legacyPublicKey.set(tweakedBytes);
     }
 }