@btc-vision/transaction 1.6.18 → 1.7.0

package/browser/index.js.LICENSE.txt

@@ -20,6 +20,8 @@
 
 /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 
+/*! noble-post-quantum - MIT License (c) 2024 Paul Miller (paulmillr.com) */
+
 /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
 
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/browser/src/_version.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.7.0";

package/browser/{epoch → src/epoch}/interfaces/IChallengeSolution.d.ts

@@ -27,6 +27,7 @@ export interface RawChallengeVerification {
     readonly proofs: readonly string[];
 }
 export interface RawChallengeSubmission {
+    readonly classicPublicKey: string;
     readonly publicKey: string;
     readonly solution: string;
     readonly graffiti?: string;
@@ -40,6 +41,7 @@ export interface IChallengeSubmission {
 }
 export interface RawChallenge {
     readonly epochNumber: string;
+    readonly classicPublicKey: string;
     readonly publicKey: string;
     readonly solution: string;
     readonly salt: string;

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

@@ -2,16 +2,19 @@ import { Network } from '@btc-vision/bitcoin';
 import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 export declare class Address extends Uint8Array {
     #private;
-    constructor(bytes?: ArrayLike<number>);
+    private classicPublicKey;
+    constructor(mldsaPublicKey?: ArrayLike<number>, publicKeyOrTweak?: ArrayLike<number>);
     get originalPublicKey(): Uint8Array | undefined;
+    get mldsaPublicKey(): Uint8Array | undefined;
     private get keyPair();
     static dead(): Address;
-    static zero(): Address;
-    static fromString(pubKey: string): Address;
+    static fromString(mldsaPublicKey: string, classicPublicKey?: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;
     toHex(): string;
+    tweakedToHex(): string;
     toBuffer(): Buffer;
+    tweakedPublicKeyToBuffer(): Buffer;
     toUncompressedHex(): string;
     toUncompressedBuffer(): Buffer;
     toHybridPublicKeyHex(): string;
@@ -20,7 +23,7 @@ export declare class Address extends Uint8Array {
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;
-    set(publicKey: ArrayLike<number>): void;
+    set(mldsaPublicKey: ArrayLike<number>): void;
     isValid(network: Network): boolean;
     p2pk(): string;
     p2wpkh(network: Network): string;

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

@@ -1,4 +1,5 @@
 import { Network } from '@btc-vision/bitcoin';
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
 export declare enum AddressTypes {
     P2PKH = "P2PKH",
     P2OP = "P2OP",
@@ -22,6 +23,8 @@ export declare class AddressVerificator {
     static isP2WDAWitnessScript(witnessScript: Buffer): boolean;
     static isP2PKHOrP2SH(addy: string, network: Network): boolean;
     static isValidPublicKey(input: string, network: Network): boolean;
+    static isValidMLDSAPublicKey(input: string | Buffer | Uint8Array): MLDSASecurityLevel | null;
+    static isValidP2OPAddress(inAddress: string, network: Network): boolean;
     static requireRedeemScript(addy: string, network: Network): boolean;
     static detectAddressType(addy: string, network: Network): AddressTypes | null;
     static detectAddressTypeWithWitnessScript(addy: string, network: Network, witnessScript?: Buffer): AddressTypes | null;

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

@@ -1,4 +1,4 @@
-import { BIP32API, BIP32Interface } from 'bip32';
+import { BIP32API, BIP32Interface, MLDSAKeyPair, MLDSASecurityLevel } from '@btc-vision/bip32';
 import { Network, Signer } from '@btc-vision/bitcoin';
 import { ECPairAPI, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
@@ -17,7 +17,8 @@ export declare class EcKeyPair {
     static xOnlyTweakedPubKeyToAddress(tweakedPubKeyHex: string, network: Network): string;
     static tweakPublicKey(pub: Uint8Array | Buffer | string): Buffer;
     static tweakBatchSharedT(pubkeys: readonly Uint8Array[], tweakScalar: bigint): Uint8Array[];
-    static generateWallet(network?: Network): IWallet;
+    static generateWallet(network?: Network, securityLevel?: MLDSASecurityLevel): IWallet;
+    static generateQuantumKeyPair(securityLevel?: MLDSASecurityLevel, network?: Network): MLDSAKeyPair;
     static verifyContractAddress(contractAddress: string, network?: Network): boolean;
     static getLegacySegwitAddress(keyPair: ECPairInterface, network?: Network): string;
     static getLegacyAddress(keyPair: ECPairInterface, network?: Network): string;

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

@@ -1,15 +1,24 @@
 import { ECPairInterface } from 'ecpair';
 import { Network } from '@btc-vision/bitcoin';
+import { MLDSASecurityLevel, QuantumBIP32Interface } from '@btc-vision/bip32';
 export interface SignedMessage {
     readonly signature: Uint8Array;
     readonly message: Uint8Array;
 }
+export interface MLDSASignedMessage {
+    readonly signature: Uint8Array;
+    readonly message: Uint8Array;
+    readonly publicKey: Uint8Array;
+    readonly securityLevel: MLDSASecurityLevel;
+}
 declare class MessageSignerBase {
     sha256(message: Buffer | Uint8Array): Buffer;
     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;
 }
 export declare const MessageSigner: MessageSignerBase;
 export {};

package/browser/src/keypair/Wallet.d.ts

@@ -0,0 +1,47 @@
+import { ECPairInterface } from 'ecpair';
+import { Network } from '@btc-vision/bitcoin';
+import { Address } from './Address.js';
+import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
+import { MLDSASecurityLevel, QuantumBIP32Interface } from '@btc-vision/bip32';
+export declare class Wallet {
+    readonly network: Network;
+    private readonly _keypair;
+    private readonly _mldsaKeypair;
+    private readonly _securityLevel;
+    private readonly _chainCode;
+    private readonly _p2wpkh;
+    private readonly _p2tr;
+    private readonly _p2wda;
+    private readonly _legacy;
+    private readonly _segwitLegacy;
+    private readonly _bufferPubKey;
+    private readonly _tweakedKey;
+    private readonly _address;
+    constructor(privateKeyOrWif: string, mldsaPrivateKeyOrBase58: string, network?: Network, securityLevel?: MLDSASecurityLevel, chainCode?: Buffer);
+    get address(): Address;
+    get tweakedPubKeyKey(): Buffer;
+    get keypair(): ECPairInterface;
+    get mldsaKeypair(): QuantumBIP32Interface;
+    get securityLevel(): MLDSASecurityLevel;
+    get chainCode(): Buffer;
+    get p2wpkh(): string;
+    get p2tr(): string;
+    get p2wda(): IP2WSHAddress;
+    get legacy(): string;
+    get addresses(): string[];
+    get segwitLegacy(): string;
+    get publicKey(): Buffer;
+    get quantumPublicKey(): Buffer;
+    get quantumPrivateKey(): Buffer;
+    get quantumPublicKeyHex(): string;
+    get quantumPrivateKeyHex(): string;
+    get xOnly(): Buffer;
+    static fromWif(wif: string, quantumPrivateKeyHex: string, network?: Network, securityLevel?: MLDSASecurityLevel, chainCode?: Buffer): Wallet;
+    static generate(network?: Network, securityLevel?: MLDSASecurityLevel): Wallet;
+    static fromPrivateKeys(privateKeyHexOrWif: string, mldsaPrivateKeyOrBase58: string, network?: Network, securityLevel?: MLDSASecurityLevel, chainCode?: Buffer): Wallet;
+    toWIF(): string;
+    toPrivateKeyHex(): string;
+    toPublicKeyHex(): string;
+    toQuantumBase58(): string;
+    derivePath(path: string): Wallet;
+}

package/browser/{keypair → src/keypair}/interfaces/IWallet.d.ts

@@ -2,4 +2,6 @@ export interface IWallet {
     readonly address: string;
     readonly privateKey: string;
     readonly publicKey: string;
+    readonly quantumPrivateKey: string;
+    readonly quantumPublicKey: string;
 }

package/browser/src/mnemonic/Mnemonic.d.ts

@@ -0,0 +1,29 @@
+import { BIP32Interface, MLDSASecurityLevel, QuantumBIP32Interface } from '@btc-vision/bip32';
+import { Network } from '@btc-vision/bitcoin';
+import { Wallet } from '../keypair/Wallet.js';
+import { MnemonicStrength } from './MnemonicStrength.js';
+export declare class Mnemonic {
+    private readonly _phrase;
+    private readonly _passphrase;
+    private readonly _network;
+    private readonly _securityLevel;
+    private readonly _seed;
+    private readonly _classicalRoot;
+    private readonly _quantumRoot;
+    constructor(phrase: string, passphrase?: string, network?: Network, securityLevel?: MLDSASecurityLevel);
+    get phrase(): string;
+    get network(): Network;
+    get securityLevel(): MLDSASecurityLevel;
+    get seed(): Buffer;
+    static generatePhrase(strength?: MnemonicStrength): string;
+    static generate(strength?: MnemonicStrength, passphrase?: string, network?: Network, securityLevel?: MLDSASecurityLevel): Mnemonic;
+    static validate(phrase: string): boolean;
+    derive(index?: number, account?: number, isChange?: boolean): Wallet;
+    deriveMultiple(count: number, startIndex?: number, account?: number, isChange?: boolean): Wallet[];
+    deriveCustomPath(classicalPath: string, quantumPath: string): Wallet;
+    getClassicalRoot(): BIP32Interface;
+    getQuantumRoot(): QuantumBIP32Interface;
+    private buildClassicalPath;
+    private buildQuantumPath;
+    private getCoinType;
+}

package/browser/src/mnemonic/MnemonicStrength.d.ts

@@ -0,0 +1,7 @@
+export declare enum MnemonicStrength {
+    MINIMUM = 128,
+    LOW = 160,
+    MEDIUM = 192,
+    HIGH = 224,
+    MAXIMUM = 256
+}

package/browser/{opnet.d.ts → src/opnet.d.ts}

@@ -19,6 +19,9 @@ export * from './keypair/EcKeyPair.js';
 export * from './keypair/interfaces/IWallet.js';
 export * from './keypair/MessageSigner.js';
 export * from './keypair/Wallet.js';
+export * from './mnemonic/Mnemonic.js';
+export * from './mnemonic/MnemonicStrength.js';
+export { MLDSASecurityLevel, MLDSAKeyPair, QuantumBIP32Interface, QuantumBIP32API, QuantumSigner, QuantumBIP32Factory, QuantumDerivationPath, } from '@btc-vision/bip32';
 export * from './metadata/ContractBaseMetadata.js';
 export * from './network/ChainId.js';
 export * from './signer/TweakedSigner.js';
@@ -66,6 +69,7 @@ export * from './transaction/browser/extensions/UnisatSigner.js';
 export * from './transaction/browser/extensions/XverseSigner.js';
 export * from './transaction/browser/types/Unisat.js';
 export * from './transaction/browser/types/Xverse.js';
+export * from './transaction/browser/types/OPWallet.js';
 export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';
 export * from './keypair/Secp256k1PointDeriver.js';

package/browser/src/transaction/browser/types/OPWallet.d.ts

@@ -0,0 +1,14 @@
+import { Unisat } from './Unisat.js';
+import { MLDSASecurityLevel } from '@btc-vision/bip32';
+export interface MLDSASignature {
+    readonly signature: string;
+    readonly publicKey: string;
+    readonly securityLevel: MLDSASecurityLevel;
+    readonly messageHash: string;
+}
+export interface OPWallet extends Unisat {
+    getMLDSAPublicKey(): Promise<string>;
+    signMLDSAMessage(message: string): Promise<MLDSASignature>;
+    verifyMLDSASignature(message: string, signature: MLDSASignature): Promise<boolean>;
+}
+export declare function isOPWallet(wallet: unknown): wallet is OPWallet;

package/browser/test/address.test.d.ts

@@ -0,0 +1 @@
+export {};

package/browser/test/addressverificator-mldsa.test.d.ts

@@ -0,0 +1 @@
+export {};

package/browser/test/derivePath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/browser/test/messagesigner-mldsa.test.d.ts

@@ -0,0 +1 @@
+export {};

package/browser/test/messagesigner-schnorr.test.d.ts

@@ -0,0 +1 @@
+export {};

package/browser/test/network-awareness.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.6.18";
+export declare const version = "1.7.0";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.6.18';
+export const version = '1.7.0';

package/build/crypto/crypto-browser.d.ts

@@ -0,0 +1,11 @@
+export function createHash(algo: any): import("@noble/hashes/utils").Hash<import("@noble/hashes/utils").Hash<any>> | undefined;
+export function createHmac(_algo: any, key: any): import("@noble/hashes/hmac").HMAC<any>;
+export function pbkdf2Sync(password: any, salt: any, iterations: any, keylen: any, _algo: any): Uint8Array<ArrayBufferLike>;
+export function randomBytes(length: any): Uint8Array<any>;
+declare namespace _default {
+    export { createHash };
+    export { createHmac };
+    export { pbkdf2Sync };
+    export { randomBytes };
+}
+export default _default;

package/build/crypto/crypto-browser.js

@@ -0,0 +1,56 @@
+import { hmac } from '@noble/hashes/hmac';
+import { pbkdf2 } from '@noble/hashes/pbkdf2';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import assert from 'assert';
+function assertArgument(check, message, name, value) {
+    assert(check, message, 'INVALID_ARGUMENT', { argument: name, value: value });
+}
+function getGlobal() {
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw new Error('unable to locate global object');
+}
+const anyGlobal = getGlobal();
+const crypto = anyGlobal.crypto || anyGlobal.msCrypto;
+export function createHash(algo) {
+    switch (algo) {
+        case 'sha256':
+            return sha256.create();
+        case 'sha512':
+            return sha512.create();
+    }
+    assertArgument(false, 'invalid hashing algorithm name', 'algorithm', algo);
+}
+export function createHmac(_algo, key) {
+    const algo = { sha256, sha512 }[_algo];
+    assertArgument(algo != null, 'invalid hmac algorithm', 'algorithm', _algo);
+    return hmac.create(algo, key);
+}
+export function pbkdf2Sync(password, salt, iterations, keylen, _algo) {
+    const algo = { sha256, sha512 }[_algo];
+    assertArgument(algo != null, 'invalid pbkdf2 algorithm', 'algorithm', _algo);
+    return pbkdf2(algo, password, salt, { c: iterations, dkLen: keylen });
+}
+export function randomBytes(length) {
+    assert(crypto != null, 'platform does not support secure random numbers', 'UNSUPPORTED_OPERATION', {
+        operation: 'randomBytes',
+    });
+    assertArgument(Number.isInteger(length) && length > 0 && length <= 1024, 'invalid length', 'length', length);
+    const result = new Uint8Array(length);
+    crypto.getRandomValues(result);
+    return result;
+}
+export default {
+    createHash,
+    createHmac,
+    pbkdf2Sync,
+    randomBytes,
+};

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);
+        this.publicKey = Address.fromString(data.publicKey, data.classicPublicKey);
         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);
+        this.publicKey = Address.fromString(data.publicKey, data.classicPublicKey);
         this.solution = stringToBuffer(data.solution);
         this.salt = stringToBuffer(data.salt);
         this.graffiti = stringToBuffer(data.graffiti);
@@ -78,6 +78,7 @@ export class ChallengeSolution {
         return {
             epochNumber: this.epochNumber.toString(),
             publicKey: this.publicKey.toHex(),
+            classicPublicKey: 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,6 +27,7 @@ export interface RawChallengeVerification {
     readonly proofs: readonly string[];
 }
 export interface RawChallengeSubmission {
+    readonly classicPublicKey: string;
     readonly publicKey: string;
     readonly solution: string;
     readonly graffiti?: string;
@@ -40,6 +41,7 @@ export interface IChallengeSubmission {
 }
 export interface RawChallenge {
     readonly epochNumber: string;
+    readonly classicPublicKey: string;
     readonly publicKey: string;
     readonly solution: string;
     readonly salt: string;

package/build/keypair/Address.d.ts

@@ -2,16 +2,19 @@ import { Network } from '@btc-vision/bitcoin';
 import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 export declare class Address extends Uint8Array {
     #private;
-    constructor(bytes?: ArrayLike<number>);
+    private classicPublicKey;
+    constructor(mldsaPublicKey?: ArrayLike<number>, publicKeyOrTweak?: ArrayLike<number>);
     get originalPublicKey(): Uint8Array | undefined;
+    get mldsaPublicKey(): Uint8Array | undefined;
     private get keyPair();
     static dead(): Address;
-    static zero(): Address;
-    static fromString(pubKey: string): Address;
+    static fromString(mldsaPublicKey: string, classicPublicKey?: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;
     toHex(): string;
+    tweakedToHex(): string;
     toBuffer(): Buffer;
+    tweakedPublicKeyToBuffer(): Buffer;
     toUncompressedHex(): string;
     toUncompressedBuffer(): Buffer;
     toHybridPublicKeyHex(): string;
@@ -20,7 +23,7 @@ export declare class Address extends Uint8Array {
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;
-    set(publicKey: ArrayLike<number>): void;
+    set(mldsaPublicKey: ArrayLike<number>): void;
     isValid(network: Network): boolean;
     p2pk(): string;
     p2wpkh(network: Network): string;