@theqrl/wallet.js 0.1.2 → 0.2.0

package/src/wallet/ml_dsa_87/crypto.js

@@ -0,0 +1,90 @@
+/**
+ * @module wallet/ml_dsa_87/crypto
+ */
+
+import {
+  cryptoSignKeypair,
+  cryptoSign,
+  cryptoSignVerify,
+  CryptoBytes,
+  CryptoPublicKeyBytes,
+  CryptoSecretKeyBytes,
+} from '@theqrl/mldsa87';
+
+/**
+ * Generate a keypair.
+ * @returns {{ pk: Uint8Array, sk: Uint8Array }}
+ */
+function keygen(seed) {
+  const pk = new Uint8Array(CryptoPublicKeyBytes);
+  const sk = new Uint8Array(CryptoSecretKeyBytes);
+  const seedBytes = new Uint8Array(seed.hashSHA256());
+  cryptoSignKeypair(seedBytes, pk, sk);
+  return { pk, sk };
+}
+
+/**
+ * Check if input is a valid byte array (Uint8Array or Buffer).
+ * @param {unknown} input
+ * @returns {boolean}
+ */
+function isBytes(input) {
+  return input instanceof Uint8Array;
+}
+
+/**
+ * Sign a message.
+ * @param {Uint8Array} sk - Secret key (must be CryptoSecretKeyBytes bytes)
+ * @param {Uint8Array} message - Message to sign
+ * @returns {Uint8Array} signature
+ * @throws {Error} If sk or message is invalid
+ */
+function sign(sk, message) {
+  if (!isBytes(sk)) {
+    throw new Error('sk must be Uint8Array or Buffer');
+  }
+  if (sk.length !== CryptoSecretKeyBytes) {
+    throw new Error(`sk must be ${CryptoSecretKeyBytes} bytes, got ${sk.length}`);
+  }
+  if (!isBytes(message)) {
+    throw new Error('message must be Uint8Array or Buffer');
+  }
+
+  const sm = cryptoSign(message, sk);
+  let signature = new Uint8Array(CryptoBytes);
+  signature = sm.slice(0, CryptoBytes);
+  return signature;
+}
+
+/**
+ * Verify a signature.
+ * @param {Uint8Array} signature - Signature to verify (must be CryptoBytes bytes)
+ * @param {Uint8Array} message - Original message
+ * @param {Uint8Array} pk - Public key (must be CryptoPublicKeyBytes bytes)
+ * @returns {boolean}
+ * @throws {Error} If signature, message, or pk is invalid
+ */
+function verify(signature, message, pk) {
+  if (!isBytes(signature)) {
+    throw new Error('signature must be Uint8Array or Buffer');
+  }
+  if (signature.length !== CryptoBytes) {
+    throw new Error(`signature must be ${CryptoBytes} bytes, got ${signature.length}`);
+  }
+  if (!isBytes(message)) {
+    throw new Error('message must be Uint8Array or Buffer');
+  }
+  if (!isBytes(pk)) {
+    throw new Error('pk must be Uint8Array or Buffer');
+  }
+  if (pk.length !== CryptoPublicKeyBytes) {
+    throw new Error(`pk must be ${CryptoPublicKeyBytes} bytes, got ${pk.length}`);
+  }
+
+  const sigBytes = new Uint8Array(signature);
+  const msgBytes = new Uint8Array(message);
+  const pkBytes = new Uint8Array(pk);
+  return cryptoSignVerify(sigBytes, msgBytes, pkBytes);
+}
+
+export { keygen, sign, verify };

package/src/wallet/ml_dsa_87/descriptor.js

@@ -0,0 +1,18 @@
+/**
+ * ML-DSA-87-specific descriptor helpers.
+ * @module /wallet/ml_dsa_87/descriptor
+ */
+
+import { Descriptor, getDescriptorBytes } from '../common/descriptor.js';
+import { WalletType } from '../common/wallettype.js';
+
+/**
+ * New ML-DSA-87 descriptor with optional 2-byte metadata.
+ * @param {[number, number]} [metadata=[0,0]]
+ * @returns {Descriptor}
+ */
+function newMLDSA87Descriptor(metadata = [0, 0]) {
+  return new Descriptor(getDescriptorBytes(WalletType.ML_DSA_87, metadata));
+}
+
+export { newMLDSA87Descriptor };

package/src/wallet/ml_dsa_87/wallet.js

@@ -0,0 +1,158 @@
+/**
+ * ML-DSA-87 Wallet object encapsulating descriptor, seeds and keypair.
+ * @module wallet/ml_dsa_87/wallet
+ */
+
+/** @typedef {import('../common/descriptor.js').Descriptor} Descriptor */
+import randomBytes from 'randombytes';
+import { bytesToHex } from '@noble/hashes/utils.js';
+import { mnemonicToBin, binToMnemonic } from '../misc/mnemonic.js';
+import { getAddressFromPKAndDescriptor, addressToString } from '../common/address.js';
+import { Seed, ExtendedSeed } from '../common/seed.js';
+import { newMLDSA87Descriptor } from './descriptor.js';
+import { keygen, sign, verify } from './crypto.js';
+
+class Wallet {
+  /**
+   * @param {{descriptor: Descriptor, seed: Seed, pk: Uint8Array, sk: Uint8Array}} opts
+   */
+  constructor({ descriptor, seed, pk, sk }) {
+    this.descriptor = descriptor;
+    this.seed = seed;
+    this.pk = pk;
+    this.sk = sk;
+    this.extendedSeed = ExtendedSeed.newExtendedSeed(descriptor, seed);
+  }
+
+  /**
+   * Create a new random wallet(non-deterministic).
+   * @param {[number, number]} [metadata=[0,0] ]
+   * @returns {Wallet}
+   */
+  static newWallet(metadata = [0, 0]) {
+    const descriptor = newMLDSA87Descriptor(metadata);
+    const seedBytes = randomBytes(48);
+    const seed = new Seed(seedBytes);
+    const { pk, sk } = keygen(seed);
+    return new Wallet({ descriptor, seed, pk, sk });
+  }
+
+  /**
+   * @param {Seed} seed
+   * @param {[number, number]} [metadata=[0,0]]
+   * @returns {Wallet}
+   */
+  static newWalletFromSeed(seed, metadata = [0, 0]) {
+    const descriptor = newMLDSA87Descriptor(metadata);
+    const { pk, sk } = keygen(seed);
+    return new Wallet({ descriptor, seed, pk, sk });
+  }
+
+  /**
+   * @param {ExtendedSeed} extendedSeed
+   * @returns {Wallet}
+   */
+  static newWalletFromExtendedSeed(extendedSeed) {
+    const descriptor = extendedSeed.getDescriptor();
+    const seed = extendedSeed.getSeed();
+    const { pk, sk } = keygen(seed);
+    return new Wallet({ descriptor, seed, pk, sk });
+  }
+
+  /**
+   * @param {string} mnemonic
+   * @returns {Wallet}
+   */
+  static newWalletFromMnemonic(mnemonic) {
+    const bin = mnemonicToBin(mnemonic);
+    const extendedSeed = new ExtendedSeed(bin);
+    return this.newWalletFromExtendedSeed(extendedSeed);
+  }
+
+  /** @returns {Uint8Array} */
+  getAddress() {
+    return getAddressFromPKAndDescriptor(this.pk, this.descriptor);
+  }
+
+  /** @returns {string} */
+  getAddressStr() {
+    return addressToString(this.getAddress());
+  }
+
+  /** @returns {Descriptor} */
+  getDescriptor() {
+    return this.descriptor;
+  }
+
+  /** @returns {ExtendedSeed} */
+  getExtendedSeed() {
+    return this.extendedSeed;
+  }
+
+  /** @returns {Seed} */
+  getSeed() {
+    return this.seed;
+  }
+
+  /** @returns {string} hex(ExtendedSeed) */
+  getHexExtendedSeed() {
+    return `0x${bytesToHex(this.extendedSeed.toBytes())}`;
+  }
+
+  /** @returns {string} */
+  getMnemonic() {
+    return binToMnemonic(this.getExtendedSeed().toBytes());
+  }
+
+  /** @returns {Uint8Array} */
+  getPK() {
+    return this.pk.slice();
+  }
+
+  /** @returns {Uint8Array} */
+  getSK() {
+    return this.sk.slice();
+  }
+
+  /**
+   * Sign a message.
+   * @param {Uint8Array} message
+   * @returns {Uint8Array} Signature bytes.
+   */
+  sign(message) {
+    return sign(this.sk, message);
+  }
+
+  /**
+   * Verify a signature.
+   * @param {Uint8Array} signature
+   * @param {Uint8Array} message
+   * @param {Uint8Array} pk
+   * @returns {boolean}
+   */
+  static verify(signature, message, pk) {
+    return verify(signature, message, pk);
+  }
+
+  /**
+   * Securely zeroize sensitive key material.
+   * Call this when the wallet is no longer needed to minimize
+   * the window where secrets exist in memory.
+   *
+   * Note: JavaScript garbage collection may retain copies;
+   * this provides best-effort zeroization.
+   */
+  zeroize() {
+    if (this.sk) {
+      this.sk.fill(0);
+    }
+    if (this.seed && this.seed.bytes) {
+      this.seed.bytes.fill(0);
+    }
+    if (this.extendedSeed && this.extendedSeed.bytes) {
+      this.extendedSeed.bytes.fill(0);
+    }
+  }
+}
+
+export { Wallet };

package/types/index.d.ts

@@ -0,0 +1,13 @@
+import { Seed } from "./wallet/common/seed.js";
+import { SEED_SIZE } from "./wallet/common/constants.js";
+import { ExtendedSeed } from "./wallet/common/seed.js";
+import { EXTENDED_SEED_SIZE } from "./wallet/common/constants.js";
+import { Descriptor } from "./wallet/common/descriptor.js";
+import { DESCRIPTOR_SIZE } from "./wallet/common/constants.js";
+import { newMLDSA87Descriptor } from "./wallet/ml_dsa_87/descriptor.js";
+import { getAddressFromPKAndDescriptor } from "./wallet/common/address.js";
+import { WalletType } from "./wallet/common/wallettype.js";
+import { newWalletFromExtendedSeed } from "./wallet/factory.js";
+import { Wallet as MLDSA87 } from "./wallet/ml_dsa_87/wallet.js";
+export { Seed, SEED_SIZE, ExtendedSeed, EXTENDED_SEED_SIZE, Descriptor, DESCRIPTOR_SIZE, newMLDSA87Descriptor, getAddressFromPKAndDescriptor, WalletType, newWalletFromExtendedSeed, MLDSA87 };
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":""}

package/types/qrl/wordlist.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Mnemonic word list used by encoding/decoding utilities.
+ * @module qrl/wordlist
+ */
+/**
+ * Ordered list of mnemonic words.
+ * @readonly
+ * @type {string[]}
+ */
+export const WordList: string[];
+//# sourceMappingURL=wordlist.d.ts.map

package/types/qrl/wordlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wordlist.d.ts","sourceRoot":"","sources":["../../src/qrl/wordlist.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;GAIG;AACH,uBAFU,MAAM,EAAE,CAmgIhB"}

package/types/utils/bytes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @param {unknown} input
+ * @returns {boolean}
+ */
+export function isUint8(input: unknown): boolean;
+/**
+ * Accepts strings with optional 0x/0X prefix and separators(space, :, _, -).
+ * @param {unknown} input
+ * @returns {boolean}
+ */
+export function isHexLike(input: unknown): boolean;
+/**
+ * Remove 0x prefix and all non-hex chars.
+ * @param {string} hex
+ * @returns {string}
+ */
+export function cleanHex(hex: string): string;
+/**
+ * Convert various inputs to a fixed-length byte array.
+ * Supports hex string(with/without 0x), Uint8Array, Buffer, number[].
+ * @param {string|Uint8Array|Buffer|number[]} input
+ * @param {number} expectedLen
+ * @param {string} [label='bytes']
+ * @returns {Uint8Array}
+ */
+export function toFixedU8(input: string | Uint8Array | Buffer | number[], expectedLen: number, label?: string): Uint8Array;
+//# sourceMappingURL=bytes.d.ts.map

package/types/utils/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/utils/bytes.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,+BAHW,OAAO,GACL,OAAO,CAInB;AAED;;;;GAIG;AACH,iCAHW,OAAO,GACL,OAAO,CAMnB;AAED;;;;GAIG;AACH,8BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,iCALW,MAAM,GAAC,UAAU,GAAC,MAAM,GAAC,MAAM,EAAE,eACjC,MAAM,UACN,MAAM,GACJ,UAAU,CAiBtB"}

package/types/wallet/common/address.d.ts

@@ -0,0 +1,17 @@
+export type Descriptor = any;
+/**
+ * Convert address bytes to string form.
+ * @param {Uint8Array} addrBytes
+ * @returns {string}
+ * @throws {Error} If length mismatch.
+ */
+export function addressToString(addrBytes: Uint8Array): string;
+/**
+ * Derive an address from a public key and descriptor.
+ * @param {Uint8Array} pk
+ * @param {Descriptor} descriptor
+ * @returns {Uint8Array} 20-byte address.
+ * @throws {Error} If pk length mismatch.
+ */
+export function getAddressFromPKAndDescriptor(pk: Uint8Array, descriptor: any): Uint8Array;
+//# sourceMappingURL=address.d.ts.map

package/types/wallet/common/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../src/wallet/common/address.js"],"names":[],"mappings":";AAUA;;;;;GAKG;AACH,2CAJW,UAAU,GACR,MAAM,CASlB;AAED;;;;;;GAMG;AACH,kDALW,UAAU,oBAER,UAAU,CAsBtB"}

package/types/wallet/common/constants.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Constants used across wallet components.
+ * @module wallet/common/constants
+ */
+/** @type {number} Size in bytes of the 3-byte descriptor */
+export const DESCRIPTOR_SIZE: number;
+/** @type {number} Address length in bytes */
+export const ADDRESS_SIZE: number;
+/** @type {number} Seed length in bytes */
+export const SEED_SIZE: number;
+/** @type {number} Extended seed length in bytes */
+export const EXTENDED_SEED_SIZE: number;
+//# sourceMappingURL=constants.d.ts.map

package/types/wallet/common/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/wallet/common/constants.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,4DAA4D;AAC5D,8BADW,MAAM,CACS;AAE1B,6CAA6C;AAC7C,2BADW,MAAM,CACO;AAExB,0CAA0C;AAC1C,wBADW,MAAM,CACI;AAErB,mDAAmD;AACnD,iCADW,MAAM,CACsC"}

package/types/wallet/common/descriptor.d.ts

@@ -0,0 +1,32 @@
+export class Descriptor {
+    /**
+     * Constructor: accepts hex string / Uint8Array / Buffer / number[].
+     * @param {string|Uint8Array|Buffer|number[]} input
+     * @returns {Descriptor}
+     */
+    static from(input: string | Uint8Array | Buffer | number[]): Descriptor;
+    /**
+     * @param {Uint8Array|number[]} bytes Must be exactly 3 bytes.
+     * @throws {Error} If size is not 3 or wallet type is invalid.
+     */
+    constructor(bytes: Uint8Array | number[]);
+    /** @private @type {Uint8Array} */
+    private bytes;
+    /**
+     * @returns {number}
+     */
+    type(): number;
+    /**
+     * Copy of internal bytes.
+     * @returns {Uint8Array}
+     */
+    toBytes(): Uint8Array;
+}
+/**
+ * Build descriptor bytes from parts.
+ * @param {number} walletType byte.
+ * @param {[number, number]} [metadata=[0,0]] Two metadata bytes.
+ * @returns {Uint8Array} 3 bytes.
+ */
+export function getDescriptorBytes(walletType: number, metadata?: [number, number]): Uint8Array;
+//# sourceMappingURL=descriptor.d.ts.map

package/types/wallet/common/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../../../src/wallet/common/descriptor.js"],"names":[],"mappings":"AAWA;IA+BE;;;;OAIG;IACH,mBAHW,MAAM,GAAC,UAAU,GAAC,MAAM,GAAC,MAAM,EAAE,GAC/B,UAAU,CAItB;IArCD;;;OAGG;IACH,mBAHW,UAAU,GAAC,MAAM,EAAE,EAY7B;IALC,kCAAkC;IAClC,cAAmC;IAMrC;;OAEG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,WAFa,UAAU,CAItB;CAUF;AAED;;;;;GAKG;AACH,+CAJW,MAAM,aACN,CAAC,MAAM,EAAE,MAAM,CAAC,GACd,UAAU,CAWtB"}

package/types/wallet/common/seed.d.ts

@@ -0,0 +1,67 @@
+export class Seed {
+    /**
+     * Constructor: accepts hex string / Uint8Array / Buffer / number[].
+     * @param {string|Uint8Array|Buffer|number[]} input
+     * @returns {Seed}
+     */
+    static from(input: string | Uint8Array | Buffer | number[]): Seed;
+    /**
+     * @param {Uint8Array} bytes Exactly 48 bytes.
+     * @throws {Error} If size mismatch.
+     */
+    constructor(bytes: Uint8Array);
+    bytes: Uint8Array;
+    /** @returns {Uint8Array} */
+    hashSHA256(): Uint8Array;
+    /**
+     * Copy of internal seed bytes.
+     * @returns {Uint8Array}
+     */
+    toBytes(): Uint8Array;
+}
+export class ExtendedSeed {
+    /**
+     * Build from components.
+     * @param {Descriptor} desc
+     * @param {Seed} seed
+     * @returns {ExtendedSeed}
+     */
+    static newExtendedSeed(desc: Descriptor, seed: Seed): ExtendedSeed;
+    /**
+     * Constructor: accepts hex string / Uint8Array / Buffer / number[].
+     * @param {string|Uint8Array|Buffer|number[]} input
+     * @returns {ExtendedSeed}
+     */
+    static from(input: string | Uint8Array | Buffer | number[]): ExtendedSeed;
+    /**
+     * Layout: [3 bytes descriptor] || [48 bytes seed].
+     * @param {Uint8Array} bytes Exactly 51 bytes.
+     * @throws {Error} If size mismatch.
+     */
+    constructor(bytes: Uint8Array);
+    /** @private @type {Uint8Array} */
+    private bytes;
+    /**
+     * @returns {Descriptor}
+     */
+    getDescriptor(): Descriptor;
+    /**
+     * @returns {Uint8Array} Descriptor(3 bytes).
+     */
+    getDescriptorBytes(): Uint8Array;
+    /**
+     * @returns {Uint8Array} Seed bytes(48 bytes).
+     */
+    getSeedBytes(): Uint8Array;
+    /**
+     * @returns {Seed}
+     */
+    getSeed(): Seed;
+    /**
+     * Copy of internal seed bytes.
+     * @returns {Uint8Array}
+     */
+    toBytes(): Uint8Array;
+}
+import { Descriptor } from "./descriptor.js";
+//# sourceMappingURL=seed.d.ts.map

package/types/wallet/common/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../../src/wallet/common/seed.js"],"names":[],"mappings":"AAWA;IAyBE;;;;OAIG;IACH,mBAHW,MAAM,GAAC,UAAU,GAAC,MAAM,GAAC,MAAM,EAAE,GAC/B,IAAI,CAIhB;IA/BD;;;OAGG;IACH,mBAHW,UAAU,EAQpB;IADC,kBAAmC;IAGrC,4BAA4B;IAC5B,cADc,UAAU,CAGvB;IAED;;;OAGG;IACH,WAFa,UAAU,CAItB;CAUF;AAED;IAqDE;;;;;OAKG;IACH,6BAJW,UAAU,QACV,IAAI,GACF,YAAY,CAOxB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GAAC,UAAU,GAAC,MAAM,GAAC,MAAM,EAAE,GAC/B,YAAY,CAIxB;IAxED;;;;OAIG;IACH,mBAHW,UAAU,EAYpB;IALC,kCAAkC;IAClC,cAAmC;IAMrC;;OAEG;IACH,iBAFa,UAAU,CAItB;IAED;;OAEG;IACH,sBAFa,UAAU,CAItB;IAED;;OAEG;IACH,gBAFa,UAAU,CAItB;IAED;;OAEG;IACH,WAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,WAFa,UAAU,CAItB;CAuBF"}

package/types/wallet/common/wallettype.d.ts

@@ -0,0 +1,19 @@
+export type WalletType = number;
+/**
+ * Wallet type enumeration.
+ * @module wallet/common/wallettype
+ */
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const WalletType: Readonly<{
+    SPHINCSPLUS_256S: 0;
+    ML_DSA_87: 1;
+}>;
+/**
+ * @param {number} t
+ * @return {boolean}
+ */
+export function isValidWalletType(t: number): boolean;
+//# sourceMappingURL=wallettype.d.ts.map

package/types/wallet/common/wallettype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallettype.d.ts","sourceRoot":"","sources":["../../../src/wallet/common/wallettype.js"],"names":[],"mappings":"yBAOU,MAAM;AAPhB;;;GAGG;AAEH;;;GAGG;AACH;;;GAGG;AAEH;;;GAGG;AACH,qCAHW,MAAM,GACL,OAAO,CAIlB"}

package/types/wallet/factory.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Construct a wallet from an ExtendedSeed by auto-selecting the correct implementation.
+ *
+ * @param {ExtendedSeed|Uint8Array|string} extendedSeed - ExtendedSeed instance, 51 bytes or hex string.
+ * @returns {any} Wallet instance (only ML-DSA-87 for now)
+ */
+export function newWalletFromExtendedSeed(extendedSeed: ExtendedSeed | Uint8Array | string): any;
+import { ExtendedSeed } from "./common/seed.js";
+//# sourceMappingURL=factory.d.ts.map

package/types/wallet/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/wallet/factory.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,wDAHW,YAAY,GAAC,UAAU,GAAC,MAAM,GAC5B,GAAG,CAiBf"}

package/types/wallet/misc/mnemonic.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Decode spaced hex mnemonic to bytes.
+ * @param {string} mnemonic
+ * @returns {Uint8Array}
+ */
+export function mnemonicToBin(mnemonic: string): Uint8Array;
+/**
+ * Encode bytes to a spaced hex mnemonic string.
+ * @param {Uint8Array} input
+ * @returns {string}
+ */
+export function binToMnemonic(input: Uint8Array): string;
+//# sourceMappingURL=mnemonic.d.ts.map

package/types/wallet/misc/mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonic.d.ts","sourceRoot":"","sources":["../../../src/wallet/misc/mnemonic.js"],"names":[],"mappings":"AAsCA;;;;GAIG;AACH,wCAHW,MAAM,GACJ,UAAU,CAiCtB;AA9DD;;;;GAIG;AACH,qCAHW,UAAU,GACR,MAAM,CAqBlB"}

package/types/wallet/ml_dsa_87/crypto.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Generate a keypair.
+ * @returns {{ pk: Uint8Array, sk: Uint8Array }}
+ */
+export function keygen(seed: any): {
+    pk: Uint8Array;
+    sk: Uint8Array;
+};
+/**
+ * Sign a message.
+ * @param {Uint8Array} sk
+ * @param {Uint8Array} message
+ * @returns {Uint8Array} signature
+ */
+export function sign(sk: Uint8Array, message: Uint8Array): Uint8Array;
+/**
+ * Verify a signature.
+ * @param {Uint8Array} signature
+ * @param {Uint8Array} message
+ * @param {Uint8Array} pk
+ * @returns {boolean}
+ */
+export function verify(signature: Uint8Array, message: Uint8Array, pk: Uint8Array): boolean;
+//# sourceMappingURL=crypto.d.ts.map

package/types/wallet/ml_dsa_87/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../../src/wallet/ml_dsa_87/crypto.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH;QAFmB,UAAU;QAAM,UAAU;EAQ5C;AAED;;;;;GAKG;AACH,yBAJW,UAAU,WACV,UAAU,GACR,UAAU,CAOtB;AAED;;;;;;GAMG;AACH,kCALW,UAAU,WACV,UAAU,MACV,UAAU,GACR,OAAO,CAOnB"}

package/types/wallet/ml_dsa_87/descriptor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * New ML-DSA-87 descriptor with optional 2-byte metadata.
+ * @param {[number, number]} [metadata=[0,0]]
+ * @returns {Descriptor}
+ */
+export function newMLDSA87Descriptor(metadata?: [number, number]): Descriptor;
+import { Descriptor } from "../common/descriptor.js";
+//# sourceMappingURL=descriptor.d.ts.map

package/types/wallet/ml_dsa_87/descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor.d.ts","sourceRoot":"","sources":["../../../src/wallet/ml_dsa_87/descriptor.js"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,gDAHW,CAAC,MAAM,EAAE,MAAM,CAAC,GACd,UAAU,CAItB"}

package/types/wallet/ml_dsa_87/wallet.d.ts

@@ -0,0 +1,74 @@
+export type Descriptor = import('../common/descriptor.js').Descriptor;
+export class Wallet {
+    /**
+     * Create a new random wallet(non-deterministic).
+     * @param {[number, number]} [metadata=[0,0] ]
+     * @returns {Wallet}
+     */
+    static newWallet(metadata?: [number, number]): Wallet;
+    /**
+     * @param {Seed} seed
+     * @param {[number, number]} [metadata=[0,0]]
+     * @returns {Wallet}
+     */
+    static newWalletFromSeed(seed: Seed, metadata?: [number, number]): Wallet;
+    /**
+     * @param {ExtendedSeed} extendedSeed
+     * @returns {Wallet}
+     */
+    static newWalletFromExtendedSeed(extendedSeed: ExtendedSeed): Wallet;
+    /**
+     * @param {string} mnemonic
+     * @returns {Wallet}
+     */
+    static newWalletFromMnemonic(mnemonic: string): Wallet;
+    /**
+     * Verify a signature.
+     * @param {Uint8Array} signature
+     * @param {Uint8Array} message
+     * @param {Uint8Array} pk
+     * @returns {boolean}
+     */
+    static verify(signature: Uint8Array, message: Uint8Array, pk: Uint8Array): boolean;
+    /**
+     * @param {{descriptor: Descriptor, seed: Seed, pk: Uint8Array, sk: Uint8Array}} opts
+     */
+    constructor({ descriptor, seed, pk, sk }: {
+        descriptor: Descriptor;
+        seed: Seed;
+        pk: Uint8Array;
+        sk: Uint8Array;
+    });
+    descriptor: import("../common/descriptor.js").Descriptor;
+    seed: Seed;
+    pk: Uint8Array;
+    sk: Uint8Array;
+    extendedSeed: ExtendedSeed;
+    /** @returns {Uint8Array} */
+    getAddress(): Uint8Array;
+    /** @returns {string} */
+    getAddressStr(): string;
+    /** @returns {Descriptor} */
+    getDescriptor(): Descriptor;
+    /** @returns {ExtendedSeed} */
+    getExtendedSeed(): ExtendedSeed;
+    /** @returns {Seed} */
+    getSeed(): Seed;
+    /** @returns {string} hex(ExtendedSeed) */
+    getHexExtendedSeed(): string;
+    /** @returns {string} */
+    getMnemonic(): string;
+    /** @returns {Uint8Array} */
+    getPK(): Uint8Array;
+    /** @returns {Uint8Array} */
+    getSK(): Uint8Array;
+    /**
+     * Sign a message.
+     * @param {Uint8Array} message
+     * @returns {Uint8Array} Signature bytes.
+     */
+    sign(message: Uint8Array): Uint8Array;
+}
+import { Seed } from "../common/seed.js";
+import { ExtendedSeed } from "../common/seed.js";
+//# sourceMappingURL=wallet.d.ts.map

package/types/wallet/ml_dsa_87/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../src/wallet/ml_dsa_87/wallet.js"],"names":[],"mappings":"yBAKc,OAAO,yBAAyB,EAAE,UAAU;AAS1D;IAYE;;;;OAIG;IACH,4BAHW,CAAC,MAAM,EAAE,MAAM,CAAC,GACd,MAAM,CAQlB;IAED;;;;OAIG;IACH,+BAJW,IAAI,aACJ,CAAC,MAAM,EAAE,MAAM,CAAC,GACd,MAAM,CAMlB;IAED;;;OAGG;IACH,+CAHW,YAAY,GACV,MAAM,CAOlB;IAED;;;OAGG;IACH,uCAHW,MAAM,GACJ,MAAM,CAMlB;IAwDD;;;;;;OAMG;IACH,yBALW,UAAU,WACV,UAAU,MACV,UAAU,GACR,OAAO,CAInB;IAvHD;;OAEG;IACH,0CAFW;QAAC,UAAU,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,IAAI,CAAC;QAAC,EAAE,EAAE,UAAU,CAAC;QAAC,EAAE,EAAE,UAAU,CAAA;KAAC,EAQ9E;IALC,yDAA4B;IAC5B,WAAgB;IAChB,eAAY;IACZ,eAAY;IACZ,2BAAkE;IAgDpE,4BAA4B;IAC5B,cADc,UAAU,CAGvB;IAED,wBAAwB;IACxB,iBADc,MAAM,CAGnB;IAED,4BAA4B;IAC5B,iBADc,UAAU,CAGvB;IAED,8BAA8B;IAC9B,mBADc,YAAY,CAGzB;IAED,sBAAsB;IACtB,WADc,IAAI,CAGjB;IAED,0CAA0C;IAC1C,sBADc,MAAM,CAGnB;IAED,wBAAwB;IACxB,eADc,MAAM,CAGnB;IAED,4BAA4B;IAC5B,SADc,UAAU,CAGvB;IAED,4BAA4B;IAC5B,SADc,UAAU,CAGvB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACR,UAAU,CAItB;CAYF"}