quantumcoin 7.0.14 → 8.0.0

package/src/utils/hashing.d.ts

@@ -1,76 +1,79 @@
-/**
- * keccak256 hash of BytesLike.
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function keccak256(data: string | Uint8Array): string;
-/**
- * sha256 hash of BytesLike.
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function sha256(data: string | Uint8Array): string;
-/**
- * sha512 hash of BytesLike.
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function sha512(data: string | Uint8Array): string;
-/**
- * ripemd160 hash of BytesLike.
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function ripemd160(data: string | Uint8Array): string;
-/**
- * ethers-style id(text) => keccak256(utf8Bytes(text))
- * @param {string} text
- * @returns {string}
- */
-export function id(text: string): string;
-/**
- * Generate cryptographically strong random bytes.
- * @param {number} length
- * @returns {Uint8Array}
- */
-export function randomBytes(length: number): Uint8Array;
-/**
- * Compute HMAC over data.
- * @param {string} algorithm
- * @param {string|Uint8Array} key
- * @param {string|Uint8Array} data
- * @returns {string}
- */
-export function computeHmac(algorithm: string, key: string | Uint8Array, data: string | Uint8Array): string;
-/**
- * PBKDF2 (sync) helper returning hex string.
- * @param {string|Uint8Array} password
- * @param {string|Uint8Array} salt
- * @param {number} iterations
- * @param {number} keylen
- * @param {string=} algorithm
- * @returns {string}
- */
-export function pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, algorithm?: string | undefined): string;
-/**
- * scrypt (async) helper returning hex string.
- * @param {string|Uint8Array} password
- * @param {string|Uint8Array} salt
- * @param {number} N
- * @param {number} r
- * @param {number} p
- * @param {number} dkLen
- * @returns {Promise<string>}
- */
-export function scrypt(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): Promise<string>;
-/**
- * scrypt (sync) helper returning hex string.
- * @param {string|Uint8Array} password
- * @param {string|Uint8Array} salt
- * @param {number} N
- * @param {number} r
- * @param {number} p
- * @param {number} dkLen
- * @returns {string}
- */
-export function scryptSync(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): string;
+/**
+ * keccak256 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function keccak256(data: string | Uint8Array): string;
+/**
+ * sha256 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function sha256(data: string | Uint8Array): string;
+/**
+ * sha512 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function sha512(data: string | Uint8Array): string;
+/**
+ * ripemd160 hash of BytesLike.
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function ripemd160(data: string | Uint8Array): string;
+/**
+ * ethers-style id(text) => keccak256(utf8Bytes(text))
+ * @param {string} text
+ * @returns {string}
+ */
+export function id(text: string): string;
+/**
+ * Generate cryptographically strong random bytes.
+ *
+ * Uses the platform Web Crypto API (`globalThis.crypto`), which is available in
+ * modern browsers and Node.js 20+.
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export function randomBytes(length: number): Uint8Array;
+/**
+ * Compute HMAC over data.
+ * @param {string} algorithm "sha256" or "sha512"
+ * @param {string|Uint8Array} key
+ * @param {string|Uint8Array} data
+ * @returns {string}
+ */
+export function computeHmac(algorithm: string, key: string | Uint8Array, data: string | Uint8Array): string;
+/**
+ * PBKDF2 (sync) helper returning hex string.
+ * @param {string|Uint8Array} password
+ * @param {string|Uint8Array} salt
+ * @param {number} iterations
+ * @param {number} keylen
+ * @param {string=} algorithm "sha256" (default) or "sha512"
+ * @returns {string}
+ */
+export function pbkdf2(password: string | Uint8Array, salt: string | Uint8Array, iterations: number, keylen: number, algorithm?: string | undefined): string;
+/**
+ * scrypt (async) helper returning hex string.
+ * @param {string|Uint8Array} password
+ * @param {string|Uint8Array} salt
+ * @param {number} N
+ * @param {number} r
+ * @param {number} p
+ * @param {number} dkLen
+ * @returns {Promise<string>}
+ */
+export function scrypt(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): Promise<string>;
+/**
+ * scrypt (sync) helper returning hex string.
+ * @param {string|Uint8Array} password
+ * @param {string|Uint8Array} salt
+ * @param {number} N
+ * @param {number} r
+ * @param {number} p
+ * @param {number} dkLen
+ * @returns {string}
+ */
+export function scryptSync(password: string | Uint8Array, salt: string | Uint8Array, N: number, r: number, p: number, dkLen: number): string;

package/src/utils/hashing.js

@@ -1,145 +1,43 @@
 /**
  * @fileoverview Hash utilities (ethers.js v6 compatible names).
  *
- * Where possible, we use Node's built-in crypto module. For keccak256,
- * we prefer a native OpenSSL implementation if available, otherwise we
- * fall back to a small pure-JS Keccak-256 implementation.
+ * All cryptographic primitives are provided by `quantum-coin-js-sdk`, which
+ * runs in both Node.js and modern browsers (WebAssembly + Web Crypto). This
+ * keeps the SDK platform agnostic and free of Node's built-in `crypto` module.
+ *
+ * NOTE: The underlying primitives require the SDK to be initialized. Call
+ * `Initialize()` (see the `quantumcoin/config` module) before using these
+ * helpers, otherwise a `NOT_INITIALIZED` error is thrown.
  */
 
-const crypto = require("crypto");
+const qcsdk = require("quantum-coin-js-sdk");
 const { arrayify, bytesToHex, utf8ToBytes } = require("../internal/hex");
+const { makeError } = require("../errors");
 
-const _MASK64 = (1n << 64n) - 1n;
-
-function _rotl64(x, n) {
-  const nn = BigInt(n);
-  return ((x << nn) | (x >> (64n - nn))) & _MASK64;
-}
-
-function _readU64LE(bytes, off) {
-  let x = 0n;
-  for (let i = 0; i < 8; i++) {
-    x |= BigInt(bytes[off + i]) << (8n * BigInt(i));
-  }
-  return x;
-}
-
-function _writeU64LE(out, off, x) {
-  let v = x & _MASK64;
-  for (let i = 0; i < 8; i++) {
-    out[off + i] = Number((v >> (8n * BigInt(i))) & 0xffn);
-  }
-}
-
-// Keccak-f[1600] round constants
-const _RC = [
-  0x0000000000000001n, 0x0000000000008082n, 0x800000000000808an, 0x8000000080008000n,
-  0x000000000000808bn, 0x0000000080000001n, 0x8000000080008081n, 0x8000000000008009n,
-  0x000000000000008an, 0x0000000000000088n, 0x0000000080008009n, 0x000000008000000an,
-  0x000000008000808bn, 0x800000000000008bn, 0x8000000000008089n, 0x8000000000008003n,
-  0x8000000000008002n, 0x8000000000000080n, 0x000000000000800an, 0x800000008000000an,
-  0x8000000080008081n, 0x8000000000008080n, 0x0000000080000001n, 0x8000000080008008n,
-];
-
-// Rotation offsets (rho step)
-const _R = [
-  // Indexed by lane index (x + 5*y) where x,y in [0..4]
-  // (This is the standard Keccak rho offsets table, flattened in y-major order.)
-  0, 1, 62, 28, 27,
-  36, 44, 6, 55, 20,
-  3, 10, 43, 25, 39,
-  41, 45, 15, 21, 8,
-  18, 2, 61, 56, 14,
-];
-
-// Pi step mapping: index -> newIndex
-const _PI = [
-  0, 10, 20, 5, 15,
-  16, 1, 11, 21, 6,
-  7, 17, 2, 12, 22,
-  23, 8, 18, 3, 13,
-  14, 24, 9, 19, 4,
-];
-
-function _keccakF1600(state) {
-  const b = new Array(25);
-  const c = new Array(5);
-  const d = new Array(5);
-
-  for (let round = 0; round < 24; round++) {
-    // Theta
-    for (let x = 0; x < 5; x++) {
-      c[x] = state[x] ^ state[x + 5] ^ state[x + 10] ^ state[x + 15] ^ state[x + 20];
-    }
-    for (let x = 0; x < 5; x++) {
-      d[x] = c[(x + 4) % 5] ^ _rotl64(c[(x + 1) % 5], 1);
-    }
-    for (let i = 0; i < 25; i++) {
-      state[i] = (state[i] ^ d[i % 5]) & _MASK64;
-    }
-
-    // Rho + Pi
-    for (let i = 0; i < 25; i++) {
-      b[_PI[i]] = _rotl64(state[i], _R[i]);
-    }
+// quantum-coin-js-sdk returns -1000 from crypto helpers when the SDK has not
+// been initialized yet, and null when the input is invalid.
+const _NOT_INITIALIZED = -1000;
 
-    // Chi
-    for (let y = 0; y < 5; y++) {
-      const row = y * 5;
-      for (let x = 0; x < 5; x++) {
-        state[row + x] = (b[row + x] ^ ((~b[row + ((x + 1) % 5)]) & b[row + ((x + 2) % 5)])) & _MASK64;
-      }
-    }
-
-    // Iota
-    state[0] = (state[0] ^ _RC[round]) & _MASK64;
-  }
-}
-
-function _keccak256Bytes(bytes) {
-  // Keccak-256: rate=1088 bits => 136 bytes
-  const rate = 136;
-  const outLen = 32;
-  const state = new Array(25).fill(0n);
-
-  let offset = 0;
-  while (offset + rate <= bytes.length) {
-    for (let i = 0; i < rate / 8; i++) {
-      state[i] = (state[i] ^ _readU64LE(bytes, offset + i * 8)) & _MASK64;
-    }
-    _keccakF1600(state);
-    offset += rate;
-  }
-
-  // Final block + padding (keccak pad10*1 with domain 0x01)
-  const block = new Uint8Array(rate);
-  const remaining = bytes.length - offset;
-  block.set(bytes.slice(offset), 0);
-  block[remaining] = 0x01;
-  block[rate - 1] |= 0x80;
-
-  for (let i = 0; i < rate / 8; i++) {
-    state[i] = (state[i] ^ _readU64LE(block, i * 8)) & _MASK64;
+/**
+ * Convert a byte array returned by a quantum-coin-js-sdk crypto helper into a
+ * normalized hex string, throwing a clear error when the SDK is not
+ * initialized or the operation failed.
+ * @param {number[]|Uint8Array|number|null} result
+ * @param {string} operation
+ * @returns {string}
+ */
+function _hexFromQcsdk(result, operation) {
+  if (result === _NOT_INITIALIZED) {
+    throw makeError(
+      "quantum-coin-js-sdk not initialized; call Initialize() first",
+      "NOT_INITIALIZED",
+      { operation },
+    );
   }
-  _keccakF1600(state);
-
-  const out = new Uint8Array(outLen);
-  let outOff = 0;
-  let lane = 0;
-  while (outOff < outLen) {
-    const tmp = new Uint8Array(8);
-    _writeU64LE(tmp, 0, state[lane]);
-    const take = Math.min(8, outLen - outOff);
-    out.set(tmp.slice(0, take), outOff);
-    outOff += take;
-    lane++;
+  if (result == null || typeof result === "number") {
+    throw makeError(`${operation} failed`, "UNKNOWN_ERROR", { operation });
   }
-  return out;
-}
-
-function _hash(alg, data) {
-  const bytes = arrayify(data);
-  return bytesToHex(crypto.createHash(alg).update(Buffer.from(bytes)).digest());
+  return bytesToHex(result instanceof Uint8Array ? result : Uint8Array.from(result));
 }
 
 /**
@@ -149,18 +47,7 @@ function _hash(alg, data) {
  */
 function keccak256(data) {
   const bytes = arrayify(data);
-  const hashes = crypto.getHashes();
-
-  // Prefer native keccak if available (varies by Node/OpenSSL build).
-  if (hashes.includes("keccak256")) {
-    return bytesToHex(crypto.createHash("keccak256").update(Buffer.from(bytes)).digest());
-  }
-  if (hashes.includes("keccak-256")) {
-    return bytesToHex(crypto.createHash("keccak-256").update(Buffer.from(bytes)).digest());
-  }
-
-  // Fallback: pure JS Keccak-256
-  return bytesToHex(_keccak256Bytes(bytes));
+  return _hexFromQcsdk(qcsdk.keccak256(bytes), "keccak256");
 }
 
 /**
@@ -169,7 +56,8 @@ function keccak256(data) {
  * @returns {string}
  */
 function sha256(data) {
-  return _hash("sha256", data);
+  const bytes = arrayify(data);
+  return _hexFromQcsdk(qcsdk.sha256(bytes), "sha256");
 }
 
 /**
@@ -178,7 +66,8 @@ function sha256(data) {
  * @returns {string}
  */
 function sha512(data) {
-  return _hash("sha512", data);
+  const bytes = arrayify(data);
+  return _hexFromQcsdk(qcsdk.sha512(bytes), "sha512");
 }
 
 /**
@@ -187,7 +76,8 @@ function sha512(data) {
  * @returns {string}
  */
 function ripemd160(data) {
-  return _hash("ripemd160", data);
+  const bytes = arrayify(data);
+  return _hexFromQcsdk(qcsdk.ripemd160(bytes), "ripemd160");
 }
 
 /**
@@ -201,16 +91,34 @@ function id(text) {
 
 /**
  * Generate cryptographically strong random bytes.
+ *
+ * Uses the platform Web Crypto API (`globalThis.crypto`), which is available in
+ * modern browsers and Node.js 20+.
  * @param {number} length
  * @returns {Uint8Array}
  */
 function randomBytes(length) {
-  return new Uint8Array(crypto.randomBytes(length));
+  const webcrypto = typeof globalThis !== "undefined" ? globalThis.crypto : undefined;
+  if (!webcrypto || typeof webcrypto.getRandomValues !== "function") {
+    throw makeError(
+      "secure random source (globalThis.crypto.getRandomValues) not available in this environment",
+      "UNKNOWN_ERROR",
+      { operation: "randomBytes" },
+    );
+  }
+  const out = new Uint8Array(length);
+  // getRandomValues rejects requests larger than 65536 bytes; fill in chunks.
+  const MAX_CHUNK = 65536;
+  for (let offset = 0; offset < length; offset += MAX_CHUNK) {
+    const chunk = out.subarray(offset, Math.min(offset + MAX_CHUNK, length));
+    webcrypto.getRandomValues(chunk);
+  }
+  return out;
 }
 
 /**
  * Compute HMAC over data.
- * @param {string} algorithm
+ * @param {string} algorithm "sha256" or "sha512"
  * @param {string|Uint8Array} key
  * @param {string|Uint8Array} data
  * @returns {string}
@@ -218,8 +126,7 @@ function randomBytes(length) {
 function computeHmac(algorithm, key, data) {
   const k = typeof key === "string" ? utf8ToBytes(key) : arrayify(key);
   const d = typeof data === "string" ? utf8ToBytes(data) : arrayify(data);
-  const h = crypto.createHmac(algorithm, Buffer.from(k)).update(Buffer.from(d)).digest();
-  return bytesToHex(new Uint8Array(h));
+  return _hexFromQcsdk(qcsdk.computeHmac(algorithm, k, d), "computeHmac");
 }
 
 /**
@@ -228,59 +135,44 @@ function computeHmac(algorithm, key, data) {
  * @param {string|Uint8Array} salt
  * @param {number} iterations
  * @param {number} keylen
- * @param {string=} algorithm
+ * @param {string=} algorithm "sha256" (default) or "sha512"
  * @returns {string}
  */
 function pbkdf2(password, salt, iterations, keylen, algorithm) {
   const p = typeof password === "string" ? utf8ToBytes(password) : arrayify(password);
   const s = typeof salt === "string" ? utf8ToBytes(salt) : arrayify(salt);
   const a = algorithm || "sha256";
-  const out = crypto.pbkdf2Sync(Buffer.from(p), Buffer.from(s), iterations, keylen, a);
-  return bytesToHex(new Uint8Array(out));
+  return _hexFromQcsdk(qcsdk.pbkdf2(p, s, iterations, keylen, a), "pbkdf2");
 }
 
 /**
- * scrypt (async) helper returning hex string.
+ * scrypt (sync) helper returning hex string.
  * @param {string|Uint8Array} password
  * @param {string|Uint8Array} salt
  * @param {number} N
  * @param {number} r
  * @param {number} p
  * @param {number} dkLen
- * @returns {Promise<string>}
+ * @returns {string}
  */
-function scrypt(password, salt, N, r, p, dkLen) {
+function scryptSync(password, salt, N, r, p, dkLen) {
   const pw = typeof password === "string" ? utf8ToBytes(password) : arrayify(password);
   const sa = typeof salt === "string" ? utf8ToBytes(salt) : arrayify(salt);
-  return new Promise((resolve, reject) => {
-    crypto.scrypt(
-      Buffer.from(pw),
-      Buffer.from(sa),
-      dkLen,
-      { N, r, p, maxmem: 128 * 1024 * 1024 },
-      (err, derived) => {
-        if (err) return reject(err);
-        resolve(bytesToHex(new Uint8Array(derived)));
-      },
-    );
-  });
+  return _hexFromQcsdk(qcsdk.scryptDeriveKey(pw, sa, N, r, p, dkLen), "scrypt");
 }
 
 /**
- * scrypt (sync) helper returning hex string.
+ * scrypt (async) helper returning hex string.
  * @param {string|Uint8Array} password
  * @param {string|Uint8Array} salt
  * @param {number} N
  * @param {number} r
  * @param {number} p
  * @param {number} dkLen
- * @returns {string}
+ * @returns {Promise<string>}
  */
-function scryptSync(password, salt, N, r, p, dkLen) {
-  const pw = typeof password === "string" ? utf8ToBytes(password) : arrayify(password);
-  const sa = typeof salt === "string" ? utf8ToBytes(salt) : arrayify(salt);
-  const out = crypto.scryptSync(Buffer.from(pw), Buffer.from(sa), dkLen, { N, r, p, maxmem: 257 * 1024 * 1024 }); //257 instead of 256 for buffer for compat for N=262144, r=8, p=1
-  return bytesToHex(new Uint8Array(out));
+function scrypt(password, salt, N, r, p, dkLen) {
+  return Promise.resolve().then(() => scryptSync(password, salt, N, r, p, dkLen));
 }
 
 module.exports = {
@@ -295,4 +187,3 @@ module.exports = {
   scrypt,
   scryptSync,
 };
-

package/src/utils/index.d.ts

@@ -1,4 +1,5 @@
 declare const _exports: {
+    FixedNumber: typeof import("./fixednumber").FixedNumber;
     formatUnits(value: import("./units").BigNumberish, decimals?: number | undefined): string;
     parseUnits(value: string, decimals?: number | undefined): bigint;
     formatEther(value: import("./units").BigNumberish): string;
@@ -58,6 +59,5 @@ declare const _exports: {
     }): string;
     getCreate2Address(from: string, salt: string, initCodeHash: string): string;
     computeAddress(key: string | Uint8Array): string;
-    FixedNumber: typeof import("./fixednumber").FixedNumber;
 };
 export = _exports;

package/src/utils/rlp.js

@@ -11,8 +11,8 @@ const { arrayify, bytesToHex, hexToBytes, isHexString, normalizeHex, utf8ToBytes
 function _toBytes(value) {
   if (value == null) return new Uint8Array([]);
 
+  // Node Buffers are Uint8Array subclasses, so this covers both.
   if (value instanceof Uint8Array) return new Uint8Array(value);
-  if (Buffer.isBuffer(value)) return new Uint8Array(value);
 
   if (Array.isArray(value)) {
     // List gets handled elsewhere; here we accept array-of-bytes as a BytesLike.

package/src/wallet/wallet.d.ts

@@ -9,6 +9,7 @@ export class SigningKey {
     constructor(privateKeyBytes: Uint8Array, publicKeyBytes: Uint8Array);
     privateKeyBytes: Uint8Array<ArrayBuffer>;
     publicKeyBytes: Uint8Array<ArrayBuffer>;
+    toJSON(): {};
 }
 /**
  * AbstractSigner base (minimal).
@@ -18,7 +19,7 @@ export class AbstractSigner {
      * @param {import("../providers/provider").AbstractProvider|null} provider
      */
     constructor(provider: import("../providers/provider").AbstractProvider | null);
-    provider: import("../providers/provider").AbstractProvider;
+    provider: import("../providers/provider").AbstractProvider | null;
     getAddress(): Promise<void>;
 }
 /**
@@ -40,6 +41,9 @@ export class BaseWallet extends AbstractSigner {
     address: string;
     readonly publicKey: string;
     readonly seed: string | null;
+    toJSON(): {
+        address: string;
+    };
     getAddress(): Promise<string>;
     /**
      * Sign a transaction using quantum-coin-js-sdk signRawTransaction().
@@ -47,6 +51,18 @@ export class BaseWallet extends AbstractSigner {
      * @returns {Promise<string>}
      */
     signTransaction(tx: import("../providers/provider").TransactionRequest): Promise<string>;
+    /**
+     * Internal: sign a transaction and return both the raw serialized transaction
+     * and the signer-computed transaction hash. The hash is later used to
+     * verify that an untrusted RPC node broadcast exactly the transaction we
+     * signed rather than substituting a different one.
+     * @param {import("../providers/provider").TransactionRequest} tx
+     * @returns {Promise<{ raw: string, hash: string|null }>}
+     */
+    _signDetailed(tx: import("../providers/provider").TransactionRequest): Promise<{
+        raw: string;
+        hash: string | null;
+    }>;
     /**
      * Signs and sends a transaction.
      * @param {import("../providers/provider").TransactionRequest} tx
@@ -59,24 +75,21 @@ export class BaseWallet extends AbstractSigner {
  */
 export class Wallet extends BaseWallet {
     /**
-     * Returns the seed phrase (list of words) if this wallet has a seed, else null.
-     * Derived from the stored pre-expansion seed via seed-words.getWordListFromSeedArray.
-     */
-    getPhrase(): string[] | null;
-    /**
-     * Returns the recommended signing context for this wallet.
-     * Setting fullSign to true may incur additional gas cost.
-     * @param {boolean|null=} fullSign  Defaults to false when null or omitted.
-     * @returns {number}
+     * Encrypts raw seed bytes into a wallet JSON string (version 5 pre-expansion format).
+     * The resulting JSON can be opened with `Wallet.fromEncryptedJsonSync()` or
+     * Desktop/Mobile/Web/CLI wallet applications.
+     * @param {number[]|Uint8Array} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
+     * @param {string|Uint8Array} password  Passphrase (at least 12 characters)
+     * @returns {string}
      */
-    getSigningContext(fullSign?: boolean | null): number;
+    static encryptSeedSync(seed: number[] | Uint8Array, password: string | Uint8Array): string;
     /**
      * Creates a new random wallet.
      * @param {import("../providers/provider").AbstractProvider=} provider
      * @param {number|null=} keyType  Optional key type: null (default=3), 3, or 5
      * @returns {Wallet}
      */
-    static createRandom(provider?: import("../providers/provider").AbstractProvider | undefined, keyType?: number | null): Wallet;
+    static createRandom(provider?: import("../providers/provider").AbstractProvider | undefined, keyType?: (number | null) | undefined): Wallet;
     /**
      * Creates a wallet from raw seed bytes.
      * @param {number[]} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
@@ -143,14 +156,36 @@ export class Wallet extends BaseWallet {
      */
     encryptSync(password: string | Uint8Array): string;
     /**
-     * Encrypts raw seed bytes into a wallet JSON string (version 5 pre-expansion format).
-     * The resulting JSON can be opened with `Wallet.fromEncryptedJsonSync()` or
-     * Desktop/Mobile/Web/CLI wallet applications.
-     * @param {number[]|Uint8Array} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
-     * @param {string|Uint8Array} password  Passphrase (at least 12 characters)
-     * @returns {string}
+     * Returns the seed phrase (list of words) if this wallet has a seed, else null.
+     * Derived from the stored pre-expansion seed via seed-words.getWordListFromSeedArray.
+     *
+     * Non-null for wallets created via createRandom, fromPhrase, fromSeed, and
+     * fromEncryptedJsonSync when the JSON is a version-5 keystore produced by
+     * encryptSync on a seed-bearing wallet or by encryptSeedSync.
+     * Null for fromKeys and for v3/v4 keystores without preExpansionSeed.
+     *
+     * @returns {string[]|null}
      */
-    static encryptSeedSync(seed: number[] | Uint8Array, password: string | Uint8Array): string;
+    getPhrase(): string[] | null;
+    /**
+     * Returns the recommended signing context for this wallet.
+     * Setting fullSign to true may incur additional gas cost.
+     * @param {boolean|null=} fullSign  Defaults to false when null or omitted.
+     * @returns {number}
+     */
+    getSigningContext(fullSign?: (boolean | null) | undefined): number;
+    /**
+     * Returns the key type of this wallet, derived from its public key length:
+     * 3 (KEY_TYPE_HYBRIDEDMLDSASLHDSA) or 5 (KEY_TYPE_HYBRIDEDMLDSASLHDSA5).
+     *
+     * The key type drives gas-price selection via `getFeeData`. Note that the
+     * underlying quantum-coin-js-sdk gas-price model supports only DynamicFeeTx
+     * (dynamic-fee transactions); legacy/other transaction fee types are not supported.
+     *
+     * @returns {number} 3 or 5.
+     * @throws if the public key length is unsupported.
+     */
+    getKeyType(): number;
     /**
      * Returns a new wallet connected to a provider.
      * @param {import("../providers/provider").AbstractProvider} provider